Hello Gemini. I have successfully used a script to extract the essential blueprints of my Android application into two manifest files.

Your task is to use these files to design and build a new, modern Android application from the ground up.

**Primary Goals & Requirements:**

1.  **Re-implement Logic:** Re-implement the core business logic found in `Manifest_Logic.txt`.
2.  **Modernize UI:** Recreate the UI structure from `Manifest_Structure.txt`, but upgrade it using modern Android UI principles (e.g., Material Design 3). I am open to your suggestions for UI improvements.
3.  **High Performance:** Prioritize performance and excellent memory management.
4.  **Modern Architecture:** Use a modern MVVM (Model-View-ViewModel) architecture.
5.  **Full Localization:** Identify all user-facing strings from the provided files, and then translate them to create the full set of 35 language resource files (shown in Languages section).
6.  **API Levels:** Configure the project with `minSdkVersion=24` and `targetSdkVersion=35`.
7.  **Command-Line Build:** The final project must be fully buildable from the command line using Gradle, with clear instructions for signing a release build with a JKS keystore.

**Languages:**

values
values-ar
values-bn
values-da
values-de
values-es
values-fi
values-fil
values-fr
values-gu
values-he
values-hi
values-id
values-it
values-ja
values-kn
values-ko
values-ml
values-mr
values-ms
values-nb
values-nl
values-pa
values-pl
values-pt-rBR
values-ru
values-sa
values-sv
values-sw
values-ta
values-te
values-th
values-tr
values-uk
values-vi
values-zh

Here is the content of the three manifest files:

**--- MANIFEST LOGIC ---**
--- FILE_START ---
PATH: app\src\androidTest\java\com\example\intentionrepeater\ExampleInstrumentedTest.kt
--- CONTENT ---
package com.anthroteacher.intentionrepeater

import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4

import org.junit.Test
import org.junit.runner.RunWith

import org.junit.Assert.*

/**
 * Instrumented test, which will execute on an Android device.
 *
 * See [testing documentation](http://d.android.com/tools/testing).
 */
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
    @Test
    fun useAppContext() {
        // Context of the app under test.
        val appContext = InstrumentationRegistry.getInstrumentation().targetContext
        assertEquals("com.anthroteacher.intentionrepeater", appContext.packageName)
    }
}
--- FILE_END ---

--- FILE_START ---
PATH: app\src\main\java\com\anthroteacher\intentionrepeater\LanguageData.kt
--- CONTENT ---
package com.anthroteacher.intentionrepeater

import android.os.Bundle
import androidx.activity.enableEdgeToEdge
import androidx.appcompat.app.AppCompatActivity
import androidx.core.view.ViewCompat
import androidx.core.view.WindowInsetsCompat
import org.intellij.lang.annotations.Language

data class Language(val code: String, val displayName: String)

// Initialize the list of languages
val languages = listOf(
    Language(code = "en", displayName = "English"),
    Language(code = "ar", displayName = "Arabic (العربية)"),
    Language(code = "bn", displayName = "Bengali (বাংলা)"),
    Language(code = "zh", displayName = "Chinese (Simplified) (中文)"),
    Language(code = "da", displayName = "Danish (Dansk)"),
    Language(code = "nl", displayName = "Dutch (Nederlands)"),
    Language(code = "fi", displayName = "Finnish (Suomi)"),
    Language(code = "fil", displayName = "Filipino (Filipino)"),
    Language(code = "fr", displayName = "French (Français)"),
    Language(code = "de", displayName = "German (Deutsch)"),
    Language(code = "gu", displayName = "Gujarati (ગુજરાતી)"),
    Language(code = "he", displayName = "Hebrew (עברית)"),
    Language(code = "hi", displayName = "Hindi (हिंदी)"),
    Language(code = "id", displayName = "Indonesian (Bahasa Indonesia)"),
    Language(code = "it", displayName = "Italian (Italiano)"),
    Language(code = "ja", displayName = "Japanese (日本語)"),
    Language(code = "kn", displayName = "Kannada (ಕನ್ನಡ)"),
    Language(code = "ko", displayName = "Korean (한국어)"),
    Language(code = "ms", displayName = "Malay (Bahasa Melayu)"),
    Language(code = "ml", displayName = "Malayalam (മലയാളം)"),
    Language(code = "mr", displayName = "Marathi (मराठी)"),
    Language(code = "nb", displayName = "Norwegian (Norsk Bokmål)"),
    Language(code = "pl", displayName = "Polish (Polski)"),
    Language(code = "pt-BR", displayName = "Portuguese (Brazil) (Português)"),
    Language(code = "pa", displayName = "Punjabi (ਪੰਜਾਬੀ)"),
    Language(code = "ru", displayName = "Russian (Русский)"),
    Language(code = "sa", displayName = "Sanskrit (संस्कृतम्)"),
    Language(code = "es", displayName = "Spanish (Español)"),
    Language(code = "sw", displayName = "Swahili (Kiswahili)"),
    Language(code = "sv", displayName = "Swedish (Svenska)"),
    Language(code = "ta", displayName = "Tamil (தமிழ்)"),
    Language(code = "te", displayName = "Telugu (తెలుగు)"),
    Language(code = "th", displayName = "Thai (ไทย)"),
    Language(code = "tr", displayName = "Turkish (Türkçe)"),
    Language(code = "uk", displayName = "Ukrainian (Українська)"),
    Language(code = "vi", displayName = "Vietnamese (Tiếng Việt)")
)
--- FILE_END ---

--- FILE_START ---
PATH: app\src\main\java\com\anthroteacher\intentionrepeater\MainActivity.kt
--- CONTENT ---
package com.anthroteacher.intentionrepeater

import Intention
import IntentionViewModel
import android.Manifest.permission.POST_NOTIFICATIONS
import android.R.attr.maxLines
import android.annotation.SuppressLint
import android.app.Activity
import android.app.Notification
import android.app.NotificationChannel
import android.app.NotificationManager
import android.app.PendingIntent
import android.app.Service
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.content.SharedPreferences
import android.content.pm.PackageManager
import android.content.res.Configuration
import android.net.Uri
import android.os.Build
import android.os.Bundle
import android.os.IBinder
import android.os.PowerManager
import android.util.Log
import androidx.activity.ComponentActivity
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.compose.setContent
import androidx.activity.result.ActivityResultLauncher
import androidx.activity.result.contract.ActivityResultContracts
import androidx.activity.viewModels
import androidx.compose.animation.core.Animatable
import androidx.compose.animation.core.animateDpAsState
import androidx.compose.animation.core.tween
import androidx.compose.foundation.ExperimentalFoundationApi
import androidx.compose.foundation.Image
import androidx.compose.foundation.ScrollState
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.gestures.detectDragGesturesAfterLongPress
import androidx.compose.foundation.gestures.detectTapGestures
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.defaultMinSize
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.layout.wrapContentHeight
import androidx.compose.foundation.lazy.LazyRow
import androidx.compose.foundation.lazy.itemsIndexed
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.ArrowBack
import androidx.compose.material.icons.filled.ArrowDropDown
import androidx.compose.material.icons.filled.ArrowForward
import androidx.compose.material.icons.filled.Delete
import androidx.compose.material.icons.filled.FiberManualRecord
import androidx.compose.material.icons.filled.Mic
import androidx.compose.material.icons.filled.Notifications
import androidx.compose.material.icons.filled.Timer
import androidx.compose.material.icons.filled.UploadFile
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.Checkbox
import androidx.compose.material3.DropdownMenuItem
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.ExposedDropdownMenuBox
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.LocalTextStyle
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Slider
import androidx.compose.material3.Text
import androidx.compose.material3.TextField
import androidx.compose.material3.TextFieldDefaults
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.livedata.observeAsState
import androidx.compose.runtime.mutableFloatStateOf
import androidx.compose.runtime.mutableLongStateOf
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.runtime.toMutableStateList
import androidx.compose.ui.Alignment
import androidx.compose.ui.ExperimentalComposeUiApi
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.platform.LocalFocusManager
import androidx.compose.ui.platform.LocalSoftwareKeyboardController
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.semantics.contentDescription
import androidx.compose.ui.semantics.semantics
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.compose.ui.zIndex
import androidx.core.app.NotificationCompat
import androidx.core.content.ContextCompat
import androidx.lifecycle.viewmodel.compose.viewModel
import androidx.localbroadcastmanager.content.LocalBroadcastManager
import com.anthroteacher.intentionrepeater.db.IntentionDBHelper
import com.anthroteacher.intentionrepeater.ui.theme.IntentionRepeaterTheme
import kotlinx.coroutines.DelicateCoroutinesApi
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import org.bouncycastle.jcajce.provider.digest.SHA3
import org.burnoutcrew.reorderable.*
import java.io.InputStream
import java.math.BigInteger
import java.math.RoundingMode
import java.util.Locale
import kotlin.math.roundToInt
import kotlin.math.roundToLong


const val version = "2.1"
private const val SETTINGS_REQUEST_CODE = 100
private const val VOICE_INTENTION_REQUEST_CODE = 101

class MainActivity : ComponentActivity() {

    private val intentionViewModel: IntentionViewModel by viewModels()
    private lateinit var requestPermissionLauncher: ActivityResultLauncher<String>
    private var isChangingConfigurations = false
    private var currentLanguage: String = "en"

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Initialize SharedPreferences
        val sharedPreferences = getSharedPreferences("AppPreferences", Context.MODE_PRIVATE)

        // Load and apply the saved locale when the activity is created
        loadLocale(sharedPreferences)

        // Setup the content UI
        setupContent()

        val isFirstLaunch = sharedPreferences.getBoolean("isFirstLaunch", true)

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
            requestPermissionLauncher = registerForActivityResult(ActivityResultContracts.RequestPermission()) { isGranted: Boolean ->
                // Handle the permission result here if needed
            }

            // Check if this is the first launch
            if (isFirstLaunch) {
                // Check if notification permission is granted
                if (ContextCompat.checkSelfPermission(this, POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
                    // Request permission
                    requestPermissionLauncher.launch(POST_NOTIFICATIONS)
                }

                // Update SharedPreferences to mark that the permission has been requested
                sharedPreferences.edit().putBoolean("isFirstLaunch", false).apply()
            }
        }
    }

    override fun onResume() {
        super.onResume()
        // Reload and apply the saved locale when the activity resumes
        val sharedPreferences = getSharedPreferences("AppPreferences", Context.MODE_PRIVATE)
        val savedLanguage = sharedPreferences.getString("Language", "en") ?: "en"

        // Check if the language has changed
        if (currentLanguage != savedLanguage) {
            currentLanguage = savedLanguage
            setLocale(this, savedLanguage)
            recreate() // Only recreate if the language has changed
        }


        isChangingConfigurations = false
    }

    // Handle result from SettingsActivity
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if (requestCode == SETTINGS_REQUEST_CODE) {
            if (resultCode == RESULT_OK) {
                // Reload locale after returning from settings
                val sharedPreferences = getSharedPreferences("AppPreferences", Context.MODE_PRIVATE)
                val savedLanguage = sharedPreferences.getString("Language", "en") ?: "en"

                // Check if the language has changed
                if (currentLanguage != savedLanguage) {
                    currentLanguage = savedLanguage
                    setLocale(this, savedLanguage)
                    recreate() // Only recreate if the language has changed
                }
            }
        }else if(requestCode == VOICE_INTENTION_REQUEST_CODE){
            if(resultCode== RESULT_OK){
                Log.d("TESTH","Coming in traditional");
            }
        }
    }

    private fun setupContent() {
        setContent {
            IntentionRepeaterTheme {
                Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
                    Greeting(
                        modifier = Modifier.padding(innerPadding)
                    )
                }
            }
        }
    }

    private fun loadLocale(sharedPreferences: SharedPreferences) {
        val savedLanguage = sharedPreferences.getString("Language", "en") ?: "en"
        currentLanguage = savedLanguage
        setLocale(this, savedLanguage)
    }

    override fun onConfigurationChanged(newConfig: Configuration) {
        super.onConfigurationChanged(newConfig)
        isChangingConfigurations = true
    }

    override fun onDestroy() {
        if (!isChangingConfigurations && isFinishing) {
            val intent = Intent(applicationContext, TimerForegroundService::class.java)
            stopService(intent)

            intentionViewModel.stopAllIntentions();
        }

        super.onDestroy()
    }

}

// Function to set the app's locale
fun setLocale(context: Context, languageCode: String) {
    val locale = Locale(languageCode)
    Locale.setDefault(locale)
    val config = Configuration()
    config.setLocale(locale)
    context.createConfigurationContext(config)
    context.resources.updateConfiguration(config, context.resources.displayMetrics)
}

fun sha512(input: String): String {
    val bytes = SHA3.Digest512().digest(input.toByteArray())
    return bytes.joinToString("") { "%02x".format(it) }
}

@OptIn(ExperimentalMaterial3Api::class, ExperimentalComposeUiApi::class)
@Composable
fun Greeting(modifier: Modifier = Modifier) {
    val context = LocalContext.current
    //val resources = context.resources
    //val configuration = resources.configuration

    //val currentLocale = configuration.locales.get(0)

    // To set a new locale:
    //val newLocale = Locale("sa") // Example: Sanskrit
    //configuration.setLocale(newLocale)
    //resources.updateConfiguration(configuration, resources.displayMetrics)

    val sharedPref = context.getSharedPreferences("AppPreferences", Context.MODE_PRIVATE)
    val locale=Locale(sharedPref.getString("Language","en").toString())

    val config = context.resources.configuration
    if (if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            config.locales[0] != locale
        } else {
            config.locale !=locale
        }
    ) {
        val newConfig = config.apply {
            setLocale(locale)
            setLayoutDirection(locale)
        }
        context.createConfigurationContext(newConfig)
        context.resources.updateConfiguration(newConfig, context.resources.displayMetrics)
    }
    val viewModel:TimerViewModel = viewModel()
    val intentionViewModel: IntentionViewModel = viewModel()

    var selectedFrequency by rememberSaveable { mutableStateOf("1") }
    var isBoostEnabled by rememberSaveable { mutableStateOf( false) }
    var targetLength by remember { mutableLongStateOf(1L) }
    var time by remember { mutableStateOf("00:00:00") }
    var timerRunning by remember { mutableStateOf(false) }
    var formattedIterations by remember { mutableStateOf(context.getString(R.string.iterations_zero_hz)) }
    var formattedIterationsCount by remember { mutableStateOf(context.getString(R.string.iterations_zero_hz)) }
    var intention by remember { mutableStateOf( "") }
    val focusManager = LocalFocusManager.current
    var sliderPosition by remember { mutableFloatStateOf(0f) }
    val fiftyPercentOfFreeMemory = remember {
        Runtime.getRuntime().let { it.maxMemory() - (it.totalMemory() - it.freeMemory()) } * 0.5
    }
    val intentions = intentionViewModel.tabs

    val scrollState = rememberScrollState()
//    var multiplier by remember { mutableStateOf(0L) }
    var isIntentionProcessed by remember { mutableStateOf(false) }
    var expanded by remember { mutableStateOf(false) }
    // Initialize `isKeepAwakeEnabled` with a default value, saving its state across recompositions
    var isKeepAwakeEnabled by rememberSaveable { mutableStateOf(false) }
    var selectedTabId by remember { mutableStateOf(intentions.first().id) }
    var selectedTab =intentions.first { it.id==selectedTabId }

    intention=selectedTab.intention;
    sliderPosition=selectedTab.multiplier.toFloat();
    isKeepAwakeEnabled=selectedTab.awakeDevice;
    selectedFrequency=selectedTab.frequency;
    isBoostEnabled=selectedTab.boostPower;
    timerRunning=selectedTab.timerRunning;


    val loadingText=context.getString(R.string.loading_intention)
    val zeroIteration=context.getString(R.string.iterations_zero_hz)

    val resultLauncher = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.OpenDocument(),
        onResult = { uri ->
            uri?.let {
                val hashedValue = hashFileContent(context, it)
                intention += hashedValue // Append the hash to the intention text box
                selectedTab.intention=intention;
                intentionViewModel.updateIntention(selectedTab);
            }
        }
    )


    Log.d("TESTH","Composer recreated");
    val audioRecordLauncher = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.StartActivityForResult(),
        onResult = { result ->
            Log.d("TESTH","In reult");
            if (result.resultCode == Activity.RESULT_OK) {
                Log.d("TESTH","Result ok");
                val savedAudioHash = sharedPref.getString("audioHash", "").toString()
                Log.d("TESTH",savedAudioHash);
                intention += savedAudioHash

                selectedTab.intention=intention;
                intentionViewModel.updateIntention(selectedTab);
            }
        }
    )

    val handleInsertFileClick = {
        resultLauncher.launch(arrayOf("*/*")) // Allow any file type
    }

    val onRecordVoiceIntentionClicked={
        val intent = Intent(context, RecordVoiceIntentionActivity::class.java)
        audioRecordLauncher.launch(intent)
    }

    val onAddClick={
        val id= intentionViewModel.addIntention(Intention(
            title = "",
            intention = "",
            multiplier = 0.0,
            frequency = "1",
            awakeDevice = false,
            boostPower = true,
            timerStartedAt = 0,
            iterationCompleted = 0.0,
            iterationCount = "",
            timerRunning = false,
            isNotification = false,
            targetLength = 0
        ))


        selectedTabId=id.toInt()
        selectedTab=intentions.first{it.id==selectedTabId}
        intention=selectedTab.intention;
        sliderPosition=selectedTab.multiplier.toFloat();
        isKeepAwakeEnabled=selectedTab.awakeDevice;
        selectedFrequency=selectedTab.frequency;
        isBoostEnabled=selectedTab.boostPower;
        timerRunning=selectedTab.timerRunning;
        targetLength=selectedTab.targetLength;

        formattedIterations=context.getString(R.string.iterations_zero_hz)
        time = "00:00:00"

        if(intentionViewModel.getStartIntentions().isNotEmpty()){
            val intent = Intent(context, TimerForegroundService::class.java)
            intent.putExtra("selectedTabId",selectedTabId);
            context.startService(intent)
        }
    }

    val onDeleteClick={
        intentionViewModel.deleteIntention(selectedTabId)
        selectedTabId=intentions.first().id
        selectedTab=intentions.first()

        intention=selectedTab.intention;
        sliderPosition=selectedTab.multiplier.toFloat();
        isKeepAwakeEnabled=selectedTab.awakeDevice;
        selectedFrequency=selectedTab.frequency;
        isBoostEnabled=selectedTab.boostPower;
        timerRunning=selectedTab.timerRunning;
        targetLength=selectedTab.targetLength;

        formattedIterations=context.getString(R.string.iterations_zero_hz)
        time = "00:00:00"

        if(intentionViewModel.getStartIntentions().isNotEmpty()){
            val intent = Intent(context, TimerForegroundService::class.java)
            intent.putExtra("selectedTabId",selectedTabId);
            context.startService(intent)
        }
    }

    val onNotificationClick={
        intentionViewModel.changeNotificationIntention(selectedTabId)
    }

    val maxMemoryUsageMB = 100f // Set the maximum allowed memory usage to 100 MB

    Box(
        modifier = Modifier
            .fillMaxSize()
            .background(Color.Black)
            .pointerInput(Unit) {
                detectTapGestures(
                    onTap = { focusManager.clearFocus() }
                )
            }
    ) {
        MainContent(
            tabList = intentions,
            selectedFrequency = selectedFrequency,
            intention = intention,
            onIntentionChange = {
                intention = it
                selectedTab.intention=intention;
                intentionViewModel.updateIntention(selectedTab);
                                },
            timerRunning = timerRunning,
            isBoostEnabled = isBoostEnabled,
            onBoostChange = {
                isBoostEnabled = it
                selectedTab.boostPower=isBoostEnabled;
                intentionViewModel.updateIntention(selectedTab);
                            },
            onFrequencyChange = { newFrequency ->
                selectedFrequency = newFrequency
                selectedTab.frequency=selectedFrequency;
                intentionViewModel.updateIntention(selectedTab);
            },
            sliderPosition = sliderPosition,
            onSliderPositionChange = { newValue ->
                sliderPosition = newValue.roundToLong().toFloat()
//                sharedPref.edit().putFloat("sliderPosition", sliderPosition).apply()
                selectedTab.multiplier=sliderPosition.toDouble();
                intentionViewModel.updateIntention(selectedTab);
            },
            time = time,
            formattedIterations = formattedIterations,
            buttonText = if (timerRunning) stringResource(R.string.str_stop) else stringResource(R.string.str_start),
            onStartStopButtonClick = {
                focusManager.clearFocus()

                Log.d("TERS","Start stop clicked");
                if (selectedTab.timerRunning) {
                    timerRunning=false;

                    selectedTab.timerRunning=false;
                    selectedTab.timerStartedAt=0;
                    selectedTab.iterationCompleted=0.0;
                    selectedTab.targetLength=0;
                    selectedTab.iterationCount="";
                    intentionViewModel.updateIntention(selectedTab);
                    Log.d("TERS","Timer stopped "+selectedTab);

                    if(intentionViewModel.getStartIntentions().isEmpty()){
                        val intent = Intent(context, TimerForegroundService::class.java)
                        context.stopService(intent)
                    }

                    formattedIterations = context.getString(R.string.finished,formattedIterationsCount)
                } else {
                    formattedIterations = loadingText
                    time = "00:00:00"
                    targetLength = sliderPosition.roundToLong() * 1024 * 1024 / 4


                    if (targetLength * 4 > fiftyPercentOfFreeMemory) {
                        targetLength = (fiftyPercentOfFreeMemory / 4).toLong()
                        sliderPosition = (4 * targetLength / 1024 / 1024).toFloat()
                        sliderPosition = sliderPosition.coerceAtMost(maxMemoryUsageMB)
                    }
                    if (sliderPosition > maxMemoryUsageMB) {
                        sliderPosition = maxMemoryUsageMB
                    }
                    targetLength = sliderPosition.roundToLong() * 1024 * 1024 / 4
//                    sharedPref.edit().putString("intention", intention).apply()
//                    sharedPref.edit().putString("frequency", selectedFrequency).apply()
//                    sharedPref.edit().putBoolean("boost_enabled", isBoostEnabled).apply()
//                    sharedPref.edit().putBoolean("keep_awake_enabled", isKeepAwakeEnabled).apply() // Ensure it saves state properly

                    selectedTab.boostPower=isBoostEnabled;
                    selectedTab.awakeDevice=isKeepAwakeEnabled;
                    selectedTab.timerRunning=true;
                    selectedTab.targetLength=targetLength;
                    selectedTab.timerStartedAt=System.nanoTime()
                    selectedTab.lastSecond=System.nanoTime()
                    selectedTab.targetLength=targetLength;

                    if(intentionViewModel.getStartIntentions().isEmpty()){
                        selectedTab.isNotification=true;
                        intentionViewModel.setNotificationIntention(selectedTab.id);
                    }

                    intentionViewModel.updateIntention(selectedTab);

                    timerRunning=true;
                    isIntentionProcessed = true

                    Log.d("TERS","Timer started "+selectedTab.timerRunning);

                    val intent = Intent(context, TimerForegroundService::class.java)
                    intent.putExtra("isInit",true);
                    intent.putExtra("selectedTabId",selectedTabId);
                    context.startService(intent)
                }
            },
            onResetButtonClick = {
                focusManager.clearFocus()
                formattedIterations = zeroIteration
                time = "00:00:00"
                selectedTab.timerStartedAt=0;
                selectedTab.timerRunning=false;
                intentionViewModel.updateIntention(selectedTab);
            },
            onInsertFileClick = handleInsertFileClick, // Pass the file selection logic
            onRecordVoiceIntentionClicked= onRecordVoiceIntentionClicked,
            onAddClick = onAddClick,
            onDeleteClick = onDeleteClick,
            onNotificationClick = onNotificationClick,
            scrollState = scrollState,
            expanded = expanded,
            onExpandChange = {
                expanded = !expanded
            },
            isKeepAwakeEnabled = isKeepAwakeEnabled,
            onKeepAwakeChange = { newValue ->
                isKeepAwakeEnabled = newValue
//                sharedPref.edit().putBoolean("keep_awake_enabled", newValue).apply()
                selectedTab.awakeDevice=newValue;
                intentionViewModel.updateIntention(selectedTab);
            },
            selectedTabId = selectedTabId,
            onTabSelected = {
                selectedTabId=it
                selectedTab=intentions.first{it.id==selectedTabId}
                intention=selectedTab.intention;
                sliderPosition=selectedTab.multiplier.toFloat();
                isKeepAwakeEnabled=selectedTab.awakeDevice;
                selectedFrequency=selectedTab.frequency;
                isBoostEnabled=selectedTab.boostPower;
                timerRunning=selectedTab.timerRunning;
                targetLength=selectedTab.targetLength;

                formattedIterations=context.getString(R.string.iterations_zero_hz)
                time = "00:00:00"

                if(intentionViewModel.getStartIntentions().isNotEmpty()){
                    val intent = Intent(context, TimerForegroundService::class.java)
                    intent.putExtra("selectedTabId",selectedTabId);
                    context.startService(intent)
                }
            }
        )
    }

    val mMessageReceiver: BroadcastReceiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context?, intent: Intent) {
            // Get extra data included in the Intent

            if(intent.hasExtra("stopTimer")){
                timerRunning=false;
//                val intents = Intent(context, TimerForegroundService::class.java)
//                context!!.stopService(intents)

                selectedTab.timerRunning=false;
                selectedTab.timerStartedAt=0;
                selectedTab.iterationCount="";
                selectedTab.iterationCompleted=0.0;
                intentionViewModel.updateIntention(selectedTab);

                formattedIterations = context!!.getString(R.string.finished,formattedIterationsCount)

                intentionViewModel.loadTabs();
            }

            if(timerRunning){
                if(intent.hasExtra("time")){
                    val times = intent.getStringExtra("time")
                    time= times.toString();
                }

                if(intent.hasExtra("iterations")){
                    val iterations = intent.getStringExtra("iterations")
                    val iterationsCount=intent.getStringExtra("iterationsCount")

                    formattedIterations= iterations.toString();
                    formattedIterationsCount=iterationsCount.toString()
                }
            }

        }
    }

    LocalBroadcastManager.getInstance(context).registerReceiver(
        mMessageReceiver, IntentFilter("IterationUpdate")
    );
}

fun getCurrentLocale(context: Context): Locale {
    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
        context.resources.configuration.locales[0]
    } else {
        context.resources.configuration.locale
    }
}

fun hashFileContent(context: Context, uri: Uri): String {
    var inputStream: InputStream? = null
    return try {
        inputStream = context.contentResolver.openInputStream(uri)
        val buffer = ByteArray(8192) // 8KB buffer
        val digest = SHA3.Digest512()
        var bytesRead: Int

        inputStream?.let { stream ->
            while (stream.read(buffer).also { bytesRead = it } != -1) {
                digest.update(buffer, 0, bytesRead)
            }
        }

        digest.digest().joinToString("") { "%02x".format(it) }.uppercase()
    } catch (e: Exception) {
        e.printStackTrace()
        ""
    } finally {
        inputStream?.close()
    }
}


@Composable
fun SimpleTabRow(
    tabs: List<Intention>,
    selectedTabId: Int,
    onTabSelected: (Int) -> Unit
) {
    val listState = rememberLazyListState()
    val coroutineScope = rememberCoroutineScope()

    Row(
        modifier = Modifier
            .fillMaxWidth()
            .padding(vertical = 8.dp),
        verticalAlignment = Alignment.CenterVertically
    ) {
        IconButton(
            onClick = {
                coroutineScope.launch {
                    val targetIndex = (listState.firstVisibleItemIndex - 1).coerceAtLeast(0)
                    listState.animateScrollToItem(targetIndex)
                }
            },
            modifier = Modifier.size(18.dp),
            enabled = listState.canScrollBackward
        ) {
            Icon(Icons.Default.ArrowBack, contentDescription = "Scroll Left", tint = Color.White)
        }

        LazyRow(
            modifier = Modifier
                .weight(1f)
                .padding(horizontal = 4.dp),
            state = listState
        ) {
            itemsIndexed(tabs) { index, tab ->
                val isSelected = tab.id == selectedTabId
                val backgroundColor = if (isSelected) Color(0xFFD0E8FF) else Color.White
                val textColor = if (isSelected) Color.Black else Color.DarkGray


                Card(
                    modifier = Modifier
                        .width(60.dp)
                        .padding(2.dp)
                        .clickable { onTabSelected(tab.id) },
                    colors = CardDefaults.cardColors(containerColor = backgroundColor),
                    elevation = CardDefaults.cardElevation(defaultElevation = 4.dp)
                ) {
                    Row(
                        verticalAlignment = Alignment.CenterVertically,
                        horizontalArrangement = Arrangement.Center,
                        modifier = Modifier
                            .fillMaxWidth()
                            .padding(horizontal = 4.dp, vertical = 2.dp)
                    ) {
                        Text(
                            text = (index+1).toString(),
                            fontSize = 12.sp,
                            color = textColor,
                            maxLines = 1,
                            overflow = TextOverflow.Ellipsis
                        )
                        if (tab.isNotification) {
                            Spacer(modifier = Modifier.width(2.dp))
                            Icon(
                                imageVector = Icons.Default.Notifications,
                                contentDescription = "Selected Tab",
                                tint = Color.Black,
                                modifier = Modifier.size(12.dp)
                            )
                        }

                        if (tab.timerRunning) {
                            Spacer(modifier = Modifier.width(2.dp))
                            Icon(
                                imageVector = Icons.Default.FiberManualRecord,
                                contentDescription = "Timer Running",
                                tint = Color(0xFF4CAF50), // Green color
                                modifier = Modifier.size(8.dp)
                            )
                        }
                    }
                }
            }
        }

        IconButton(
            onClick = {
                coroutineScope.launch {
                    val targetIndex = (listState.firstVisibleItemIndex + 1).coerceAtMost(tabs.lastIndex)
                    listState.animateScrollToItem(targetIndex)
                }
            },
            modifier = Modifier.size(18.dp),
            enabled = listState.canScrollForward
        ) {
            Icon(Icons.Default.ArrowForward, contentDescription = "Scroll Right", tint = Color.White)
        }
    }
}


@Composable
    private fun MainContent(
    tabList: List<Intention>,
    selectedFrequency: String,
    intention: String,
    onFrequencyChange: (String) -> Unit,
    isBoostEnabled: Boolean,
    onBoostChange: (Boolean) -> Unit,
    onIntentionChange: (String) -> Unit,
    timerRunning: Boolean,
    sliderPosition: Float,
    onSliderPositionChange: (Float) -> Unit,
    time: String,
    formattedIterations: String,
    buttonText: String,
    onStartStopButtonClick: () -> Unit,
    onResetButtonClick: () -> Unit,
    onInsertFileClick: () -> Unit,
    onRecordVoiceIntentionClicked: ()->Unit,
    onAddClick: ()->Unit,
    onDeleteClick: () -> Unit,
    onNotificationClick: () -> Unit,
    scrollState: ScrollState,
    expanded: Boolean,
    onExpandChange: (Boolean) -> Unit,
    isKeepAwakeEnabled: Boolean, // Add parameter for keep awake state
    onKeepAwakeChange: (Boolean) -> Unit, // Callback for changing the keep awake state
    selectedTabId : Int,
    onTabSelected: (Int) -> Unit
) {
    val context = LocalContext.current // Correctly obtain the context in Compose
    val selectedTab=tabList.first { it.id == selectedTabId };

    Column(
        modifier = Modifier
            .fillMaxSize()
            .verticalScroll(scrollState)
            .padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        AppTitle()
        SimpleTabRow(
            tabs = tabList,
            selectedTabId = selectedTabId,
            onTabSelected = onTabSelected
        )
        IntentionTextField(
            intention = intention,
            onIntentionChange = onIntentionChange,
            timerRunning = timerRunning
        )
        FileVoiceSelector(timerRunning=timerRunning,onInsertFileClick = onInsertFileClick, onRecordVoiceIntentionClicked = onRecordVoiceIntentionClicked, onAddClick = onAddClick,onDeleteClick=onDeleteClick,onNotificationClick=onNotificationClick,selectedTab=selectedTab)
        MultiplierSlider(
            sliderPosition = sliderPosition,
            onSliderPositionChange = onSliderPositionChange,
            timerRunning = timerRunning
        )
        FrequencyAndBoostSelector(
            selectedFrequency = selectedFrequency,
            onFrequencyChange = onFrequencyChange,
            isBoostEnabled = isBoostEnabled,
            onBoostChange = onBoostChange,
            timerRunning = timerRunning,
            expanded=expanded,
            onExpandChange=onExpandChange
        )
        // Checkbox for keeping the device awake
        KeepDeviceAwakeCheckbox(
            selectedFrequency = selectedFrequency,
            isKeepAwakeEnabled = isKeepAwakeEnabled,
            onKeepAwakeChange = onKeepAwakeChange,
            timerRunning = timerRunning
        )
        TimerDisplay(time = time)
        IterationsDisplay(formattedIterations = formattedIterations)
        Spacer(modifier = Modifier.size(24.dp))
        StartStopResetButtons(
            buttonText = buttonText,
            onStartStopButtonClick = onStartStopButtonClick,
            onResetButtonClick = onResetButtonClick,
            timerRunning = timerRunning,
            intention = intention
        )

        Spacer(modifier = Modifier.size(24.dp))

        Row(
            verticalAlignment = Alignment.CenterVertically, // Align items vertically in the center
            horizontalArrangement = Arrangement.Center, // Center the items horizontally within the row
            modifier = Modifier.fillMaxWidth() // Make the row fill the available width
        ) {
            // Gear Icon Button to open SettingsActivity
            IconButton(
                onClick = {
                    val intent = Intent(context, SettingsActivity::class.java)
                    (context as? MainActivity)?.startActivityForResult(intent, SETTINGS_REQUEST_CODE)
                },
                modifier = Modifier.size(56.dp)
            ) {
                Image(
                    painter = painterResource(id = R.drawable.ic_settings_gear),
                    contentDescription = stringResource(R.string.settings),
                    modifier = Modifier.size(56.dp)
                )
            }

            Spacer(modifier = Modifier.width(16.dp)) // Optional spacer to add space between items

            // Version Display
            VersionDisplay() // Remove the modifier parameter since it's not defined in VersionDisplay
        }

    }
}

@Composable
private fun SettingsButton() {
    val context = LocalContext.current
    Button(
        onClick = {
            val intent = Intent(context, SettingsActivity::class.java)
            context.startActivity(intent)
        },
        colors = ButtonDefaults.buttonColors(
            contentColor = Color.White,
            containerColor = Color.Blue
        ),
        modifier = Modifier
            .width(150.dp)
            .height(48.dp)
    ) {
        Text(
            text = stringResource(R.string.settings),
            color = Color.White,
            fontSize = 24.sp,
            fontFamily = FontFamily.Serif,
            fontWeight = FontWeight.Bold
        )
    }
}

@Composable
private fun AppTitle() {
    Spacer(modifier = Modifier.size(16.dp))
    val text = stringResource(R.string.intention_repeater_header)
    Text(
        text = text,
        fontSize = 24.sp,
        fontFamily = FontFamily.Serif,
        color = Color.White
    )
    Text(
        text = stringResource(R.string.by_anthro_teacher),
        fontSize = 20.sp,
        fontFamily = FontFamily.Serif,
        color = Color.White
    )
}

@OptIn(ExperimentalComposeUiApi::class, ExperimentalMaterial3Api::class)
@Composable
private fun IntentionTextField(
    intention: String,
    onIntentionChange: (String) -> Unit,
    timerRunning: Boolean
) {
    val keyboardController = LocalSoftwareKeyboardController.current
    val focusManager = LocalFocusManager.current

    OutlinedTextField(
        value = intention,
        readOnly = timerRunning,
        onValueChange = onIntentionChange,
        modifier = Modifier
            .fillMaxWidth()
            .height(192.dp),
        label = { Text(stringResource(R.string.enter_intentions), color = Color.White) },
        singleLine = false,
        keyboardOptions = KeyboardOptions.Default.copy(
            imeAction = ImeAction.Default
        ),
        keyboardActions = KeyboardActions(
            onDone = {
                keyboardController?.hide()
                focusManager.clearFocus()
            }
        ),
        colors = TextFieldDefaults.outlinedTextFieldColors(
            cursorColor = Color.White,
            focusedBorderColor = Color.Blue,
            unfocusedBorderColor = Color.Gray
        ),
        textStyle = LocalTextStyle.current.copy(color = Color.White, lineHeight = 24.sp),
        maxLines = Int.MAX_VALUE
    )
}


@Composable
private fun FileVoiceSelector(
    timerRunning: Boolean,
    // Add onClick handlers for the new icons
    // Keep existing handlers
    onInsertFileClick: () -> Unit,
    onRecordVoiceIntentionClicked: () -> Unit,
    onAddClick: () -> Unit,
    onDeleteClick: () -> Unit,
    onNotificationClick: () -> Unit,
    selectedTab:Intention
) {
    val viewModel: IntentionViewModel = viewModel();

    Row(
        modifier = Modifier.fillMaxWidth(),
        // Remove Arrangement.End, Spacer will handle positioning
        // Add verticalAlignment for consistency
        verticalAlignment = Alignment.CenterVertically
    ) {
        // --- Left Icons ---
        IconButton(
            onClick = onAddClick,
            modifier = Modifier.size(40.dp)
        ) {
            Icon(
                Icons.Filled.Add,
                contentDescription = "Add",
                // Apply tint logic consistently
                tint = Color.White
            )
        }
        if(viewModel.tabs.size>1){
            IconButton(
                onClick = onDeleteClick,
                enabled = !timerRunning,
                modifier = Modifier.size(40.dp)
            ) {
                Icon(
                    Icons.Filled.Delete,
                    contentDescription = "Delete",
                    tint = if (!timerRunning) Color.White else Color.Gray
                )
            }
        }

        if(!selectedTab.isNotification){
            IconButton(
                onClick = onNotificationClick,
                modifier = Modifier.size(40.dp)
            ) {
                Icon(
                    Icons.Filled.Notifications,
                    contentDescription = "Notifications",
                    tint = Color.White
                )
            }
        }

        // --- Spacer to push next items to the end ---
        Spacer(modifier = Modifier.weight(1f))

        // --- Right Icons (Existing) ---
        IconButton(
            onClick = onInsertFileClick,
            enabled = !timerRunning,
            modifier = Modifier.size(40.dp)
        ) {
            Icon(
                Icons.Filled.UploadFile,
                contentDescription = "Load File",
                tint = if (!timerRunning) Color.White else Color.Gray
            )
        }
        IconButton(
            onClick = onRecordVoiceIntentionClicked,
            enabled = !timerRunning,
            modifier = Modifier.size(40.dp)
        ) {
            Icon(
                Icons.Filled.Mic,
                contentDescription = "Record Voice", // Updated content description slightly
                tint = if (!timerRunning) Color.White else Color.Gray
            )
        }
    }
}

@Composable
private fun MultiplierSlider(
    sliderPosition: Float,
    onSliderPositionChange: (Float) -> Unit,
    timerRunning: Boolean
) {
    Column(
        modifier = Modifier.padding(4.dp),
        verticalArrangement = Arrangement.Center,
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Row(
            verticalAlignment = Alignment.CenterVertically,
            modifier = Modifier.fillMaxWidth()
        ) {
            Text(
                text = stringResource(R.string.multiplier, sliderPosition.roundToLong()),
                fontSize = 14.sp,
                fontFamily = FontFamily.Serif,
                color = Color.White
            )
            Spacer(modifier = Modifier.width(4.dp))
            Slider(
                value = sliderPosition,
                enabled = !timerRunning,
                onValueChange = onSliderPositionChange,
                valueRange = 0f..100f,
                steps = 19,
                modifier = Modifier.weight(1f)
            )
            Spacer(modifier = Modifier.width(4.dp))
            Text(
                text = "100",
                fontSize = 14.sp,
                fontFamily = FontFamily.Serif,
                color = Color.White
            )
        }
    }
}

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun FrequencyAndBoostSelector(
    selectedFrequency: String,
    onFrequencyChange: (String) -> Unit,
    isBoostEnabled: Boolean,
    onBoostChange: (Boolean) -> Unit,
    timerRunning: Boolean,
    expanded: Boolean,
    onExpandChange:(Boolean) -> Unit,
) {
    data class Option(val title: String, val value: String)
    val options = listOf(
        Option(stringResource(R.string.three_herz_classic),"3"),
        Option(stringResource(R.string.schumann_resonance),"7.83"),
        Option(stringResource(R.string.str_maximum_frequency),"0"),
        Option(stringResource(R.string.once_per_hour),"1")
    )

    Column(
        modifier = Modifier.fillMaxWidth(),
        verticalArrangement = Arrangement.Top,
        horizontalAlignment = Alignment.Start
    ) {
        ExposedDropdownMenuBox(
            expanded = expanded,
            onExpandedChange = {
                if(!timerRunning){
                    onExpandChange(!expanded)
                }
            }
        ) {
            TextField(
                readOnly = true,
                value = if(selectedFrequency=="3") options[0].title else if(selectedFrequency=="7.83") options[1].title else if(selectedFrequency=="0") options[2].title else options[3].title,
                onValueChange = {},
                modifier = Modifier
                    .fillMaxWidth()
                    .menuAnchor(),
                trailingIcon = {
                    Icon(
                        imageVector = Icons.Filled.ArrowDropDown,
                        contentDescription = ""
                    )
                }
            )
            ExposedDropdownMenu(
                expanded = expanded,
                modifier = Modifier.fillMaxWidth(),
                onDismissRequest = { onExpandChange(false) }
            ) {
                options.forEach { option ->
                    DropdownMenuItem(
                        text = { Text(option.title) },
                        onClick = {
                            onFrequencyChange(option.value)
                            onExpandChange(false)
                        }
                    )
                }
            }
        }

        Row(
            modifier = Modifier
                .fillMaxWidth()
                .padding(start = 8.dp) // Aligns both checkboxes to the left
                .height(48.dp), // Set the height of the row to 48 dp
            verticalAlignment = Alignment.CenterVertically,
            horizontalArrangement = Arrangement.Start
        ) {
            Checkbox(
                checked = isBoostEnabled,
                onCheckedChange = { onBoostChange(it) },
                enabled = !timerRunning,
                modifier = Modifier
                    .size(24.dp) // Size of the checkbox itself
                    .width(56.dp)
                    .semantics { contentDescription = "Power Boost (Enables SHA-512 Encoding)" }
            )
            Spacer(modifier = Modifier.width(8.dp)) // Add spacing between the checkbox and text
            Text(
                text = stringResource(R.string.power_boost_uses_sha512_encoding),
                color = Color.White,
                fontSize = 14.sp, // Match the font size
                fontFamily = FontFamily.Serif,
                modifier = Modifier
                    .weight(1f) // Make the text take up remaining space in the row
                    .height(48.dp) // Ensures the text aligns vertically within the 48dp height
                    .wrapContentHeight(Alignment.CenterVertically) // Centers the text vertically within its container
            )
        }

    }
}

@Composable
fun KeepDeviceAwakeCheckbox(
    selectedFrequency: String,
    isKeepAwakeEnabled: Boolean,
    onKeepAwakeChange: (Boolean) -> Unit,
    timerRunning: Boolean
) {
    // Determine if the checkbox should be enabled or disabled
    val isCheckboxEnabled = (selectedFrequency == "3" || selectedFrequency == "7.83" || selectedFrequency == "1") && !timerRunning

    // Tooltip state
    var showTooltip by remember { mutableStateOf(false) }

    Box(modifier = Modifier.padding(start = 8.dp, top = 8.dp)) { // Align with other checkbox
        Row(
            verticalAlignment = Alignment.CenterVertically,
            modifier = Modifier
                .fillMaxWidth()
                .pointerInput(Unit) {
                    detectTapGestures(
                        onLongPress = { showTooltip = true },
                        onTap = { showTooltip = false }
                    )
                }
        ) {
            Row(
                modifier = Modifier
                    .fillMaxWidth()
                    .height(48.dp), // Set the row height to 48.dp
                verticalAlignment = Alignment.CenterVertically // Center the contents vertically
            ) {
                Checkbox(
                    checked = isKeepAwakeEnabled, // Always use the state without modification
                    onCheckedChange = {
                        if (isCheckboxEnabled) {
                            onKeepAwakeChange(it)
                        }
                    },
                    enabled = isCheckboxEnabled,
                    modifier = Modifier
                        .size(24.dp) // Size of the checkbox itself
                        .width(56.dp)
                        .semantics { contentDescription = "Keep Device Awake" }
                )
                Spacer(modifier = Modifier.width(8.dp)) // Add spacing between the checkbox and text
                Text(
                    text = stringResource(R.string.keep_device_awake),
                    color = if (isCheckboxEnabled) Color.White else Color.Gray,
                    fontSize = 14.sp, // Match the font size with "Power Boost"
                    fontFamily = FontFamily.Serif,
                    modifier = Modifier
                        .padding(start = 4.dp)
                        .align(Alignment.CenterVertically) // Center the text vertically within the row
                )
            }

        }

        if (showTooltip) {
            Box(
                modifier = Modifier
                    .align(Alignment.TopStart)
                    .padding(start = 36.dp)
                    .background(
                        Color.DarkGray,
                        shape = androidx.compose.foundation.shape.RoundedCornerShape(4.dp)
                    )
                    .padding(8.dp)
            ) {
                Text(
                    text = stringResource(R.string.prevents_device_sleeping),
                    color = Color.White,
                    fontSize = 12.sp
                )
            }
        }
    }
}

@Composable
private fun TimerDisplay(time: String) {
    Text(
        text = time,
        fontSize = 48.sp,
        fontFamily = FontFamily.Serif,
        color = Color.White
    )
}

@Composable
private fun IterationsDisplay(formattedIterations: String) {
    Text(
        text = formattedIterations,
        fontSize = 20.sp,
        textAlign = TextAlign.Center,
        fontFamily = FontFamily.Serif,
        color = Color.White
    )
}

@Composable
private fun StartStopResetButtons(
    buttonText: String,
    onStartStopButtonClick: () -> Unit,
    onResetButtonClick: () -> Unit,
    timerRunning: Boolean,
    intention: String
) {
    // Start and Reset buttons on the first line
    Row(
        modifier = Modifier.fillMaxWidth(),
        horizontalArrangement = Arrangement.SpaceEvenly
    ) {
        Button(
            onClick = onStartStopButtonClick,
            enabled = intention.isNotBlank(),
            contentPadding = PaddingValues(all = 8.dp),
            modifier = Modifier
                .weight(1f)
                .defaultMinSize(minWidth = 1.dp, minHeight = 1.dp)
                .height(48.dp),
            colors = ButtonDefaults.buttonColors(
                contentColor = Color.White,
                containerColor = if(timerRunning) Color.Red else Color.Green
            )
        ) {
            Text(
                text = buttonText,
                color = if(timerRunning) Color.White else Color.Black,
                fontSize = 14.sp,
                fontFamily = FontFamily.Serif,
                fontWeight = FontWeight.Bold
            )
        }
        Spacer(modifier = Modifier.size(8.dp))
        Button(
            onClick = onResetButtonClick,
            enabled = !timerRunning,
            contentPadding = PaddingValues(all = 8.dp),
            modifier = Modifier
                .weight(1f)
                .height(48.dp)
                .defaultMinSize(minHeight = 1.dp, minWidth = 1.dp),
            colors = ButtonDefaults.buttonColors(
                contentColor = Color.White,
                containerColor = Color.Blue
            )
        ) {
            Text(
                text = stringResource(R.string.reset),
                color = Color.White,
                fontSize = 14.sp,
                fontFamily = FontFamily.Serif,
                fontWeight = FontWeight.Bold
            )
        }
    }

    Spacer(modifier = Modifier.size(8.dp))

    // Insert File button on its own line
//    Row(
//        modifier = Modifier.fillMaxWidth(),
//        horizontalArrangement = Arrangement.Center
//    ) {
//        IconButton(
//            onClick = onInsertFileClick,
//            modifier = Modifier.size(52.dp)
//        ) {
//            Icon(Icons.Filled.UploadFile,  contentDescription = "Load File", tint = Color.White)
//        }
//        IconButton(
//            onClick = onRecordVoiceIntentionClicked,
//            modifier = Modifier.size(52.dp)
//        ) {
//            Icon(Icons.Filled.Mic,  contentDescription = "Load File", tint = Color.White)
//        }
//    }
}

@Composable
fun WebsiteButton(modifier: Modifier) {
    val context = LocalContext.current
    Button(
        onClick = {
            val url = "https://www.intentionrepeater.com"
            val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
            context.startActivity(intent)
        },
        colors = ButtonDefaults.buttonColors(
            contentColor = Color.Black,
            containerColor = Color.Green
        ),
        modifier = modifier
    ) {
        Text(
            text = stringResource(R.string.website),
            color = Color.Black,
            fontSize = 14.sp,
            fontFamily = FontFamily.Serif,
            fontWeight = FontWeight.Bold
        )
    }
}

@Composable
fun ForumButton(modifier: Modifier) {
    val context = LocalContext.current

    Button(
        onClick = {
            val url = "https://intentionrepeater.boards.net/"
            val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
            context.startActivity(intent)
        },
        colors = ButtonDefaults.buttonColors(
            contentColor = Color.Black,
            containerColor = Color.Green
        ),
        modifier = modifier
    ) {
        Text(
            text = stringResource(R.string.forum),
            color = Color.Black,
            fontSize = 14.sp,
            fontFamily = FontFamily.Serif,
            fontWeight = FontWeight.Bold
        )
    }
}

@Composable
private fun VersionDisplay() {
    Row(
        verticalAlignment = Alignment.CenterVertically,
        horizontalArrangement = Arrangement.Center
    ) {
        Text(
            text = stringResource(R.string.str_version, version),
            color = Color.White,
            fontSize = 14.sp,
            fontFamily = FontFamily.Serif,
            fontWeight = FontWeight.Bold
        )
    }
}

@Composable
fun EulaButton(modifier: Modifier) {
    val context = LocalContext.current

    Button(
        onClick = {
            val url = "https://www.intentionrepeater.com/android_eula.html"
            val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
            context.startActivity(intent)
        },
        colors = ButtonDefaults.buttonColors(
            contentColor = Color.Black,
            containerColor = Color.Green
        ),
        modifier = modifier
    ) {
        Text(
            text = stringResource(R.string.eula),
            color = Color.Black,
            fontSize = 14.sp,
            fontFamily = FontFamily.Serif,
            fontWeight = FontWeight.Bold
        )
    }
}

@Composable
fun PrivacyPolicyButton(modifier: Modifier) {
    val context = LocalContext.current

    Button(
        onClick = {
            val url = "https://www.intentionrepeater.com/android_privacy_policy.html"
            val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
            context.startActivity(intent)
        },
        colors = ButtonDefaults.buttonColors(
            contentColor = Color.Black,
            containerColor = Color.Green
        ),
        modifier = modifier
    ) {
        Text(
            text = stringResource(R.string.privacy),
            color = Color.Black,
            fontSize = 14.sp,
            fontFamily = FontFamily.Serif,
            fontWeight = FontWeight.Bold
        )
    }
}

fun formatDecimalNumber(context: Context,value:Float):String{
    val units = arrayOf(context.getString(R.string.Hz), context.getString(R.string.kHz), context.getString(R.string.MHz), context.getString(R.string.GHz), context.getString(R.string.THz), context.getString(R.string.PHz), context.getString(R.string.EHz))
    var adjustedValue = value
    var unitIndex = 0

    // Adjust the value to the correct unit
    while (adjustedValue >= 1000 && unitIndex < units.size - 1) {
        adjustedValue /= 1000
        unitIndex++
    }

    // Format the frequency
    return if(adjustedValue==7.83.toFloat()) {
        // Otherwise, show it with three decimal places
        String.format("%.2f %s", adjustedValue, units[unitIndex])
    }else{
        String.format("%.3f %s", adjustedValue, units[unitIndex])
    }
}


fun formatLargeNumber(context:Context,value: BigInteger): String {
    if (value < BigInteger("1000")) {
        return value.toString()
    }

    val names = arrayOf("", context.getString(R.string.k), context.getString(R.string.M), context.getString(R.string.B), context.getString(R.string.T), context.getString(R.string.q), context.getString(R.string.Q), context.getString(R.string.s), context.getString(R.string.S))
    val magnitude = value.toString().length
    val index = (magnitude - 1) / 3

    if (index >= names.size) {
        return value.toString()
    }

    val divisor = BigInteger.TEN.pow(index * 3)
    val formattedValue =
        value.toBigDecimal().divide(divisor.toBigDecimal(), 3, RoundingMode.HALF_UP)

    return String.format("%.3f%s", formattedValue, names[index])
}

fun formatLargeFreq(context: Context,value: Float): String {
    val units = arrayOf(context.getString(R.string.Hz), context.getString(R.string.kHz), context.getString(R.string.MHz), context.getString(R.string.GHz), context.getString(R.string.THz), context.getString(R.string.PHz), context.getString(R.string.EHz))
    var adjustedValue = value
    var unitIndex = 0

    // Adjust the value to the correct unit
    while (adjustedValue >= 1000 && unitIndex < units.size - 1) {
        adjustedValue /= 1000
        unitIndex++
    }

    // Format the frequency
    return if(unitIndex==0) {
        // Otherwise, show it with three decimal places
        String.format("%.0f %s", adjustedValue, units[unitIndex])
    }else{
        String.format("%.3f %s", adjustedValue, units[unitIndex])
    }
}


class TimerForegroundService : Service() {
    companion object {
        const val NOTIFICATION_ID = 1
    }

    private lateinit var wakeLock: PowerManager.WakeLock

    override fun onBind(intent: Intent?): IBinder? {
        return null
    }


    private lateinit var sharedPreferences:SharedPreferences
    private lateinit var context:Context;
    private lateinit var  dbHelper: IntentionDBHelper

    override fun onCreate() {
        super.onCreate()
        dbHelper=IntentionDBHelper(applicationContext)
        sharedPreferences=getSharedPreferences("AppPreferences", Context.MODE_PRIVATE)
        val savedLanguage = sharedPreferences.getString("Language", "en") ?: "en"
        context=this;

//        val filter = IntentFilter("com.example.SEND_TO_SERVICE")
//        ContextCompat.registerReceiver(
//            context,
//            dataReceiver,
//            filter,
//            ContextCompat.RECEIVER_NOT_EXPORTED
//        )

        setLocale(context, savedLanguage)
    }


    private val dataReceiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context?, intent: Intent?) {
            val data = intent?.getStringExtra("message_key")
            Log.d("MyService", "Received via Broadcast: $data")
        }
    }

    fun updateLocale(locale: Locale) {
        Locale.setDefault(locale)
        val config = context.resources.configuration
        config.setLocale(locale)
        config.setLayoutDirection(locale) // Important for RTL languages
        context= context.createConfigurationContext(config)
        context.resources.updateConfiguration(config, context.resources.displayMetrics)
    }

    private var intentionList = mutableListOf<Intention>();

    private var timerRunning = false
    private var durationSec=0L
    private var selectedTabId:Int=-1;
    private val listLock = Any()


    @SuppressLint("WakelockTimeout")
    @OptIn(DelicateCoroutinesApi::class)
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        createNotificationChannel()
        val sharedPreferences = getSharedPreferences("AppPreferences", Context.MODE_PRIVATE)

        Log.d("TESTR","IN onstart commm");
        // Use safe call operator and provide default values
        intent?.let { safeIntent ->

                selectedTabId=safeIntent.getIntExtra("selectedTabId",-1);
                val notification = createNotification(context.getString(R.string.intention_repeater_header)+" 00:00:00", context.getString(R.string.loading_intention),true)
                startForeground(NOTIFICATION_ID, notification)

                // Acquire a partial wake lock
                val powerManager = getSystemService(Context.POWER_SERVICE) as PowerManager
                wakeLock = powerManager.newWakeLock(
                    PowerManager.PARTIAL_WAKE_LOCK,
                    "TimerForegroundService::WakeLock"
                )

                durationSec=sharedPreferences.getLong("Duration",0L) * 1000

            synchronized(listLock) {
                intentionList.removeAll { !it.timerRunning }

                val fetchedIntentions = dbHelper.getStartIntentions()
                val existingIds = intentionList.map { it.id }.toSet()
                val newIntentions = fetchedIntentions.filter { it.id !in existingIds }

                for (item in newIntentions) {
                    val intentionBuilder = StringBuilder()
                    var localMultiplier = 0L

                    if (item.targetLength > 0) {
                        while (intentionBuilder.length < item.targetLength) {
                            intentionBuilder.append(item.intention)
                            localMultiplier++
                        }
                    } else {
                        localMultiplier = 1
                        intentionBuilder.append(item.intention)
                    }

                    item.newIntention = intentionBuilder.toString()
                    item.newMultiplier = localMultiplier
                }

                intentionList.addAll(newIntentions)
            }

//                intentionList.removeAll { it.timerRunning == false }
//
//                val fetchedIntentions = dbHelper.getStartIntentions()
//
//                val existingIds = intentionList.map { it.id }.toSet()
//                val newIntentions = fetchedIntentions.filter { it.id !in existingIds }
//
//                for (item in newIntentions) {
//                    val intentionBuilder = StringBuilder()
//                    var localMultiplier = 0L
//
//                    if (item.targetLength > 0) {
//                        while (intentionBuilder.length < item.targetLength) {
//                            intentionBuilder.append(item.intention)
//                            localMultiplier++
//                        }
//                    } else {
//                        localMultiplier = 1
//                        intentionBuilder.append(item.intention)
//                    }
//
//                    item.newIntention = intentionBuilder.toString()
//                    item.newMultiplier = localMultiplier
//                }
//
//                intentionList.addAll(newIntentions)

//                intentionList=dbHelper.getStartIntentions().toMutableStateList();
//
//                for (item in intentionList) {
//                    val intentionBuilder = StringBuilder()
//                    var localMultiplier = 0L
//
//                    if (item.targetLength > 0) {
//                        while (intentionBuilder.length < item.targetLength) {
//                            intentionBuilder.append(item.intention)
//                            localMultiplier++
//                        }
//                    } else {
//                        localMultiplier = 1
//                        intentionBuilder.append(item.intention)
//                    }
//
//                    item.newIntention = intentionBuilder.toString()
//                    item.newMultiplier = localMultiplier
//                }


                if(isWakeEnabled()){
                    wakeLock.acquire();
                }else{
                    wakeLock.acquire(10 * 60 * 1000L /* 10 minutes */)
                }

                val intentUpdate = Intent("IterationUpdate")

                timerRunning=dbHelper.getStartIntentions().isNotEmpty();
                Log.d("TERS","Timer in command "+timerRunning);
                if (dbHelper.getStartIntentions().size==1 && safeIntent.hasExtra("isInit")) {
                    Log.d("TERR","Started intention");
                    GlobalScope.launch(Dispatchers.Default) {
                        startTimer(onTimeUpdate = {
                            intentUpdate.putExtra("time", it)

                            LocalBroadcastManager.getInstance(applicationContext).sendBroadcast(intentUpdate)
                        }, onIterationsUpdate ={ s: String, s1: String ->
                            intentUpdate.putExtra("iterations", s)
                            intentUpdate.putExtra("iterationsCount",s1);

                            LocalBroadcastManager.getInstance(applicationContext).sendBroadcast(intentUpdate)
                        }, onTimerStop = {
                            intentUpdate.putExtra("stopTimer",true);

                            LocalBroadcastManager.getInstance(applicationContext).sendBroadcast(intentUpdate)
                        })
                    }
            }
        } ?: run {
            stopSelf()
            return START_NOT_STICKY
        }
        return START_STICKY
    }

    private fun isWakeEnabled(): Boolean {
        return dbHelper.getStartIntentions().any { it.awakeDevice }
    }

//    suspend fun startTimer(
//        onTimeUpdate: (String) -> Unit,
//        onIterationsUpdate: (String, String) -> Unit,
//        onTimerStop: (Boolean) -> Unit
//    ) {
//        Log.d("TESTF","Timer start");
//        while (timerRunning) {
//            val savedLanguage = sharedPreferences.getString("Language", "en") ?: "en"
//            if (savedLanguage != context.resources.configuration.locale.toString()) {
//                updateLocale(Locale(savedLanguage))
//            }
//
//            val now = System.nanoTime()
//
//            val snapshotList = synchronized(listLock) { intentionList.toList() }
//            for (intention in snapshotList) {
//                Log.d("TESTF","Intention loop");
//                Log.d("TESTF",intention.intention);
//                if (!intention.timerRunning) continue
//
//                val loopStart = System.nanoTime()
//
//                if (intention.boostPower) {
//                    intention.mutableIntention =
//                        sha512("${intention.mutableIntention}: ${intention.newIntention}")
//                }
//
//                val freq = intention.frequency.toDoubleOrNull() ?: continue
//                val shouldDelay = freq in listOf(1.0, 3.0, 7.83)
//
//                if (!shouldDelay) {
//                    intention.iterationsInLastSecond++
//                } else {
//                    val timeTakenNs = System.nanoTime() - loopStart
//                    val delayMs = (1.0 / freq) * 1000.0
//                    val remainingDelayMs = delayMs - (timeTakenNs / 1_000_000.0)
//                    preciseDelay(remainingDelayMs)
//                }
//
//                if (intention.frequency == "1" && !intention.isFirstIterationSet) {
//                    intention.iterationsInLastSecond = 1.0
//                    intention.iterations += 1.0 * intention.multiplier
//                    intention.isFirstIterationSet = true
//                }
//
//                if (now - intention.lastSecond >= 1_000_000_000L) {
//                    val ss=dbHelper.getIntentionById(intention.id);
//                    intention.timerRunning=ss.timerRunning;
//                    if (!intention.timerRunning) continue
//
//                    Log.d("TESTF","Inside one second loop");
//
//                    intention.lastSecond=now;
//
//                    val freq = intention.frequency.toDoubleOrNull() ?: continue
//
//                    when (freq) {
//                        3.0 -> intention.iterationsInLastSecond = 3.0
//                        7.83 -> intention.iterationsInLastSecond = 7.83
//                        1.0 -> {
//                            val elapsedSec =
//                                (System.nanoTime() - intention.timerStartedAt) / 1_000_000_000L
//                            intention.iterationsInLastSecond =
//                                if ((elapsedSec % 3600).toInt() == 0) 1.0 else 0.0
//                        }
//                    }
//
//                    intention.elapsedTime =
//                        (System.nanoTime() - intention.timerStartedAt) / 1_000_000L
//                    intention.iterations += intention.iterationsInLastSecond * intention.multiplier
//
//                    val hours = intention.elapsedTime / 3600000
//                    val minutes = (intention.elapsedTime / 60000) % 60
//                    val seconds = (intention.elapsedTime / 1000) % 60
//
//                    val updatedTime =
//                        String.format(Locale.ENGLISH, "%02d:%02d:%02d", hours, minutes, seconds)
//                    intention.lastTime = updatedTime
//
//                    Log.d("TESTF",updatedTime);
//
//                    val iterationString = context.getString(
//                        R.string.str_iterations,
//                        formatLargeNumber(
//                            context,
//                            BigInteger.valueOf(intention.iterations.toLong())
//                        ),
//                        when (freq) {
//                            7.83 -> formatDecimalNumber(
//                                context,
//                                7.83f * intention.multiplier.toFloat()
//                            )
//
//                            3.0 -> formatLargeFreq(context, 3f * intention.multiplier.toFloat())
//                            1.0 -> formatLargeNumber(
//                                context,
//                                BigInteger.valueOf((1f * intention.multiplier.toFloat()).toLong())
//                            ) + "/hr"
//
//                            else -> formatLargeFreq(
//                                context,
//                                (intention.iterationsInLastSecond * intention.multiplier).toFloat()
//                            )
//                        }
//                    )
//
//                    Log.d("TESTF",iterationString);
//
//                    intention.updatedIterationCount = formatLargeNumber(
//                        context,
//                        BigInteger.valueOf(intention.iterations.toLong())
//                    )
//
//                    // Stop condition check
//                    if ( durationSec>0&&intention.elapsedTime-1000>=durationSec) {
//                        intention.timerRunning = false
//                        withContext(Dispatchers.Main) {
//                            onTimerStop(true)
//                        }
//                        continue
//                    }
//
//                    dbHelper.updateIntention(intention);
//                    Log.d("TESTF","Updated intentions");
//                    withContext(Dispatchers.Main) {
//                        Log.d("TESTF","Send updated");
//
//                        if(selectedTabId==intention.id && intention.timerRunning){
//                            onTimeUpdate(updatedTime)
//                            onIterationsUpdate(iterationString, intention.updatedIterationCount)
//                        }
//
//                        if (intention.isNotification && intention.timerRunning) {
//                            val notification = createNotification(
//                                context.getString(R.string.intention_repeater_header) + " " + updatedTime,
//                                iterationString,
//                                true
//                            )
//                            val notificationManager =
//                                getSystemService(NOTIFICATION_SERVICE) as NotificationManager
//                            notificationManager.notify(intention.id, notification)
//                        }
//                    }
//
//                    // Reset for next second
//                    intention.iterationsInLastSecond = 0.0
//                    intention.lastSecond = now
//
//                    timerRunning=dbHelper.getStartIntentions().isNotEmpty();
//                    Log.d("TERS","Timer running "+timerRunning);
//                    Log.d("TERS",dbHelper.getStartIntentions().toString());
//                }
//            }
//        }
//    }



    suspend fun startTimer(
        onTimeUpdate: (String) -> Unit,
        onIterationsUpdate: (String, String) -> Unit,
        onTimerStop: (Boolean) -> Unit
    ) {
        Log.d("TIMER", "Starting Timer")

        var lastTickTime = System.nanoTime()

        while (timerRunning) {
            val currentTime = System.nanoTime()
            val deltaNs = currentTime - lastTickTime

            // Ensure roughly 1s loop accuracy
            if (deltaNs < 1_000_000_000L) {
                preciseDelaySafe((1_000_000_000.0 - deltaNs) / 1_000_000.0)
                continue
            }
            lastTickTime = currentTime

            val savedLanguage = sharedPreferences.getString("Language", "en") ?: "en"
            if (savedLanguage != context.resources.configuration.locale.toString()) {
                updateLocale(Locale(savedLanguage))
            }

            val snapshotList = synchronized(listLock) { intentionList.toList() }

            for (intention in snapshotList) {

                val ss=dbHelper.getIntentionById(intention.id);
                intention.timerRunning=ss.timerRunning;
                intention.isNotification = ss.isNotification

                if(!intention.timerRunning && intention.isNotification){
                    val ll=dbHelper.getStartIntentions();
                    if(ll.isNotEmpty()){
                        dbHelper.setNotificationIntention(ll.first().id)
                    }
                }

                if (!intention.timerRunning) continue

                if (intention.boostPower) {
                    intention.mutableIntention = sha512("${intention.mutableIntention}: ${intention.newIntention}")
                }

                val freq = intention.frequency.toDoubleOrNull() ?: continue

                // One-time setup for 1/hr intentions
//                if (freq == 1.0 && !intention.isFirstIterationSet) {
//                    intention.iterationsInLastSecond = 1.0
//                    intention.iterations += 1.0 * intention.multiplier
//                    intention.isFirstIterationSet = true
//                }

                val timeNow = System.nanoTime()
//                val elapsedSec = (timeNow - intention.timerStartedAt) / 1_000_000_000L

                // Frequency-based updates
                when (freq) {
                    3.0, 7.83 -> intention.iterationsInLastSecond = freq
                    1.0 -> {
                        val elapsedSec = (System.nanoTime() - intention.timerStartedAt) / 1_000_000_000L
                        val currentHour = elapsedSec / 3600

                        if (!intention.isFirstIterationSet) {
                            intention.iterationsInLastSecond = 1.0
                            intention.isFirstIterationSet = true
                            intention.lastHourMark = currentHour
                        } else if (currentHour > intention.lastHourMark) {
                            intention.iterationsInLastSecond = 1.0
                            intention.lastHourMark = currentHour
                        } else {
                            // NO increment this tick
                            intention.iterationsInLastSecond = 0.0
                        }
                    }
                    else -> intention.iterationsInLastSecond++
                }

                intention.elapsedTime = (timeNow - intention.timerStartedAt) / 1_000_000L
                intention.iterations += intention.iterationsInLastSecond * intention.multiplier

                val hours = intention.elapsedTime / 3600000
                val minutes = (intention.elapsedTime / 60000) % 60
                val seconds = (intention.elapsedTime / 1000) % 60

                val updatedTime = String.format(Locale.ENGLISH, "%02d:%02d:%02d", hours, minutes, seconds)
                intention.lastTime = updatedTime

                val iterationString = context.getString(
                    R.string.str_iterations,
                    formatLargeNumber(context, BigInteger.valueOf(intention.iterations.toLong())),
                    when (freq) {
                        7.83 -> formatDecimalNumber(context, 7.83f * intention.multiplier.toFloat())
                        3.0 -> formatLargeFreq(context, 3f * intention.multiplier.toFloat())
                        1.0 -> formatLargeNumber(context, BigInteger.valueOf((1f * intention.multiplier).toLong())) + "/hr"
                        else -> formatLargeFreq(context, (intention.iterationsInLastSecond * intention.multiplier).toFloat())
                    }
                )

                intention.updatedIterationCount = formatLargeNumber(
                    context,
                    BigInteger.valueOf(intention.iterations.toLong())
                )

                // Check for stop condition
                if (durationSec > 0 && intention.elapsedTime >= durationSec) {
                    intention.timerRunning = false
                    withContext(Dispatchers.Main) {
                        onTimerStop(true)
                    }
                    continue
                }

                // DB Update
                withContext(Dispatchers.IO) {
                    dbHelper.updateIntention(intention)
                }

                // UI Update
                withContext(Dispatchers.Main) {
                    if (selectedTabId == intention.id && intention.timerRunning) {
                        onTimeUpdate(updatedTime)
                        onIterationsUpdate(iterationString, intention.updatedIterationCount)
                    }

                    if (intention.isNotification && intention.timerRunning) {
                        val notification = createNotification(
                            context.getString(R.string.intention_repeater_header) + " " + updatedTime,
                            iterationString,
                            true
                        )
                        val notificationManager = getSystemService(NOTIFICATION_SERVICE) as NotificationManager
                        notificationManager.notify(NOTIFICATION_ID, notification)
                    }
                }

                intention.iterationsInLastSecond = 0.0
            }

            // Refresh timerRunning check
            timerRunning = withContext(Dispatchers.IO) { dbHelper.getStartIntentions().isNotEmpty() }
        }
    }


    suspend fun preciseDelaySafe(milliseconds: Double) {
        val wholeMilliseconds = milliseconds.toLong()
        val fractionalMilliseconds = milliseconds - wholeMilliseconds
        val nanoseconds = (fractionalMilliseconds * 1_000_000).toInt().coerceIn(0, 999999)

        if (wholeMilliseconds > 0) {
            delay(wholeMilliseconds)
        }
        if (nanoseconds > 0) {
            delay((nanoseconds / 1_000_000).toLong())
        }
    }
    fun preciseDelay(milliseconds: Double) {
        // Split milliseconds into whole and fractional parts
        val wholeMilliseconds = milliseconds.toLong() // Whole part of the milliseconds
        val fractionalMilliseconds = milliseconds - wholeMilliseconds // Fractional part
        val nanoseconds = (fractionalMilliseconds * 1_000_000).toInt().coerceIn(0, 999999) // Convert to nanoseconds

        // Use Thread.sleep for the precise delay
        if (wholeMilliseconds > 0 || nanoseconds > 0) {
            Thread.sleep(wholeMilliseconds, nanoseconds)
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        // Release the wake lock when the service is destroyed
        if (::wakeLock.isInitialized && wakeLock.isHeld) {
            wakeLock.release()
        }
        timerRunning=false
        stopForeground(true)
        stopSelf()
//        val notification=createNotification(context.getString(R.string.intention_repeater_finished),context.getString(R.string.str_iterations,updatedIterationCount,lastTime),false)
//
//        val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
//
//        notificationManager.notify(100,notification)
    }

    private fun createNotification(title:String,text:String,isSticky:Boolean): Notification {
        val notificationBuilder = NotificationCompat.Builder(context, context.getString(R.string.app_name))

        if (Build.VERSION.SDK_INT >=
            Build.VERSION_CODES.S
        ) {
            notificationBuilder.setForegroundServiceBehavior(Notification.FOREGROUND_SERVICE_IMMEDIATE)
        }

        val pendingIntent = createPendingIntent(applicationContext)


        return notificationBuilder
            .setContentTitle(title)
            .setContentText(text)
            .setContentIntent(pendingIntent)
            .setSmallIcon(android.R.drawable.ic_dialog_info)
            .setOnlyAlertOnce(true)
            .setOngoing(isSticky)
            .setAutoCancel(false)
            .setPriority(NotificationCompat.PRIORITY_HIGH)
            .build()
    }

    fun createPendingIntent(context: Context): PendingIntent {
        // Intent to start an activity when the notification is tapped
        val intent = Intent(context, MainActivity::class.java)

        // Create a PendingIntent for the intent
        return PendingIntent.getActivity(
            context,
            0,
            intent,
            PendingIntent.FLAG_MUTABLE
        )
    }

    private fun createNotificationChannel() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val serviceChannel = NotificationChannel(
                getString(R.string.app_name),
                getString(R.string.show_intentions_update),
                NotificationManager.IMPORTANCE_HIGH
            )
            val manager =
                getSystemService(NotificationManager::class.java)
            manager.createNotificationChannel(serviceChannel)
        }
    }
}

@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
    IntentionRepeaterTheme {
        Greeting()
    }
}
--- FILE_END ---

--- FILE_START ---
PATH: app\src\main\java\com\anthroteacher\intentionrepeater\RecordVoiceIntentionActivity.kt
--- CONTENT ---
package com.anthroteacher.intentionrepeater

import android.content.Context
import android.content.Intent
import android.content.SharedPreferences
import android.content.pm.PackageManager
import android.media.MediaPlayer
import android.media.MediaRecorder
import android.net.Uri
import android.os.Bundle
import android.provider.CalendarContract.Colors
import android.provider.Settings
import android.util.Log
import androidx.activity.ComponentActivity
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.compose.setContent
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Mic
import androidx.compose.material.icons.filled.Pause
import androidx.compose.material.icons.filled.PlayArrow
import androidx.compose.material.icons.filled.Stop
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.ColorScheme
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.ui.Alignment
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.shadow
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.core.content.ContextCompat
import com.anthroteacher.intentionrepeater.ui.theme.BlueLight
import com.anthroteacher.intentionrepeater.ui.theme.DarkColorScheme
import com.anthroteacher.intentionrepeater.ui.theme.FireRed
import com.anthroteacher.intentionrepeater.ui.theme.IntentionRepeaterTheme
import com.anthroteacher.intentionrepeater.ui.theme.LightColorScheme
import com.anthroteacher.intentionrepeater.ui.theme.SafetyOrange
import kotlinx.coroutines.delay
import org.bouncycastle.jcajce.provider.digest.SHA3
import org.bouncycastle.jce.provider.BouncyCastleProvider
import java.io.File
import java.io.FileInputStream
import java.io.IOException
import java.security.Security
import java.util.Locale


class RecordVoiceIntentionActivity : ComponentActivity() {
    private var mediaRecorder: MediaRecorder? = null
    private var mediaPlayer: MediaPlayer? = null
    var outputFile: String = ""

    private lateinit var sharedPreferences: SharedPreferences

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        sharedPreferences = getSharedPreferences("AppPreferences", Context.MODE_PRIVATE)
        outputFile = "${externalCacheDir?.absolutePath}/recorded_audio.3gp"
        Security.addProvider(BouncyCastleProvider())

        loadLocale()

        setContent {
            IntentionRepeaterTheme {
                RecordVoiceScreen(
                    onRecord = { startRecording() },
                    onStop = { stopRecording() },
                    onPlay = { isPaused, onPlaySet, onAudioComplete ->
                        startPlaying(isPaused, onPlaySet, onAudioComplete)
                    },
                    onPause = { pausePlaying() },
                    onStopPlayback = { stopPlayback() },
                    onSave = { saveHashAndClose() },
                    onCancel = {
                        finish()
                    } // Finish activity on cancel
                )
            }
        }
    }


    private fun loadLocale() {
        val savedLanguage = sharedPreferences.getString("Language", "en") ?: "en"
        setLocale(this, savedLanguage) // Apply the saved or default locale
    }

    private fun setLocale(context: Context, languageCode: String) {
        val locale = Locale(languageCode)
        Locale.setDefault(locale)

        val resources = context.resources
        val config = resources.configuration
        config.setLocale(locale)
        config.setLayoutDirection(locale)

        context.createConfigurationContext(config)
        resources.updateConfiguration(config, resources.displayMetrics)
    }

    private fun startRecording() {
        mediaRecorder = MediaRecorder().apply {
            setAudioSource(MediaRecorder.AudioSource.MIC)
            setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP)
            setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
            setAudioSamplingRate(44100)
            setOutputFile(outputFile)
            try {
                prepare()
                start()
            } catch (e: IOException) {
                e.printStackTrace()
            }
        }
    }

    private fun stopRecording() {
        mediaRecorder?.apply {
            stop()
            release()
        }
        mediaRecorder = null
    }

    private fun startPlaying(isPaused:Boolean,onPlaySet:() -> Unit ,onAudioComplete: () -> Unit) {

        if(isPaused){
            mediaPlayer!!.seekTo(mediaPlayer!!.currentPosition);
            mediaPlayer!!.start();
            onPlaySet()
        }else{
            mediaPlayer = MediaPlayer().apply {
                setOnCompletionListener {
                    onAudioComplete()
                }
                try {
                    setDataSource(outputFile)
                    prepare()
                    start()
                } catch (e: IOException) {
                    e.printStackTrace()
                }
            }
        }

    }

    private fun pausePlaying() {
        mediaPlayer?.apply {
            if (isPlaying) {
                pause()
            }
        }
    }

    private fun stopPlayback() {
        mediaPlayer?.apply {
            stop()
            reset()
            release()
        }
        mediaPlayer = null
    }

    fun hashFile(filePath: String): String {
        val file = File(filePath)
        val digest = SHA3.Digest512()

        FileInputStream(file).use { fis ->
            val buffer = ByteArray(8192)
            var bytesRead: Int
            while (fis.read(buffer).also { bytesRead = it } != -1) {
                digest.update(buffer, 0, bytesRead)
            }
        }

        return digest.digest().joinToString("") { "%02x".format(it) }
    }

    private fun saveHashAndClose() {
        val hashValue = hashFile(outputFile)
        sharedPreferences.edit().putString("audioHash", hashValue).apply()

        val file=File(outputFile);
        file.deleteOnExit();
        setResult(RESULT_OK)
        finish()
    }
}

@Composable
fun RecordVoiceScreen(
    onRecord: () -> Unit,
    onStop: () -> Unit,
    onPlay: (isPaused:Boolean,onPlaySet:()->Unit,onAudioComplete: () -> Unit) -> Unit,
    onPause: () -> Unit,
    onStopPlayback: () -> Unit,
    onSave: () -> Unit,
    onCancel: () -> Unit
) {
    var isRecording by remember { mutableStateOf(false) }
    var isRecorded by remember { mutableStateOf(false) }
    var isPlaying by remember { mutableStateOf(false) }
    var isPaused by remember { mutableStateOf(false) }
    var timeInSeconds by remember { mutableStateOf(0) }
    var recordedTimeInSeconds by remember { mutableStateOf(0) }
    var audioPlayTimeInSeconds by remember { mutableStateOf(0) }
    var isTimerRunning by remember { mutableStateOf(false) }
    var showPermissionDialog by remember { mutableStateOf(false) }
    var hashValue by remember { mutableStateOf("") }

    val context = LocalContext.current
    val activity = context as RecordVoiceIntentionActivity

    val permissionLauncher = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.RequestPermission(),
        onResult = { isGranted ->
            if (isGranted) {
                onRecord()
                isRecording = true
                isTimerRunning = true
            } else {
                showPermissionDialog = true
            }
        }
    )

    LaunchedEffect(isTimerRunning) {
        if (isTimerRunning) {
            while (timeInSeconds < 60 && isRecording) {
                delay(1000L)
                timeInSeconds++
            }
            if (timeInSeconds >= 60) {
                onStop()
                isRecording = false
                isTimerRunning = false
                isRecorded = true
                recordedTimeInSeconds=timeInSeconds;
                timeInSeconds = 0
            }
        }
    }

    LaunchedEffect(isPlaying) {
        if (isPlaying) {
            while (isPlaying) {
                delay(1000L)
                audioPlayTimeInSeconds++
            }
        }
    }

    Column(
        modifier = Modifier
            .fillMaxSize()
            .background(Color.Black)
            .padding(16.dp),
        verticalArrangement = Arrangement.SpaceBetween,
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Column(
            verticalArrangement = Arrangement.Top,
            horizontalAlignment = Alignment.CenterHorizontally,
            modifier = Modifier.fillMaxWidth()
        ) {
            Text(
                text = stringResource(R.string.record_voice_intention),
                style = MaterialTheme.typography.headlineSmall,
                color = Color.White
            )
            Spacer(modifier = Modifier.height(8.dp))
            Text(
                style = MaterialTheme.typography.bodyMedium,
                textAlign = TextAlign.Justify,
                modifier = Modifier.fillMaxWidth(),
                text = stringResource(R.string.record_voice_description),
                color = Color.White
            )
        }

        Column(
            verticalArrangement = Arrangement.Center,
            horizontalAlignment = Alignment.CenterHorizontally,
            modifier = Modifier.fillMaxWidth()
        ) {
            Text(
                text = if (isRecording) stringResource(R.string.recording)
                else if (isPlaying) stringResource(R.string.playing)
                else if (isPaused) stringResource(R.string.paused)
                else if (isRecorded) stringResource(R.string.tap_play_listen)
                else stringResource(R.string.tap_mic_record),
                color =  Color.White,
                fontSize = 20.sp,
                fontFamily = FontFamily.Serif,
            )
            Spacer(modifier = Modifier.height(16.dp))
            Row(verticalAlignment = Alignment.Bottom) {
                Text(
                    text = if (isRecording) "${timeInSeconds / 60}:${(timeInSeconds % 60).toString().padStart(2, '0')}"
                    else if (isPlaying || isPaused) "${audioPlayTimeInSeconds / 60}:${(audioPlayTimeInSeconds % 60).toString().padStart(2, '0')}"
                    else "${timeInSeconds / 60}:${(timeInSeconds % 60).toString().padStart(2, '0')}",
                    color = if(isRecording && timeInSeconds>=30) FireRed else Color.White,
                    fontSize = 48.sp,
                    fontFamily = FontFamily.Serif,
                )
                if(isRecorded){
                    Text(text ="/${recordedTimeInSeconds / 60}:${(recordedTimeInSeconds % 60).toString().padStart(2, '0')}", color = Color.White, modifier = Modifier.padding(bottom = 10.dp))
                }
            }

            Spacer(modifier = Modifier.height(16.dp))

            if (!isRecording && !isRecorded) {
                IconButton(
                    onClick = {
                        when {
                            ContextCompat.checkSelfPermission(context, android.Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED -> {
                                onRecord()
                                isRecording = true
                                isTimerRunning = true
                            }
                            else -> {
                                permissionLauncher.launch(android.Manifest.permission.RECORD_AUDIO)
                            }
                        }
                    },
                    modifier = Modifier.size(72.dp)
                ) {
                    Icon(Icons.Filled.Mic, modifier = Modifier.size(120.dp), contentDescription = stringResource(
                        R.string.record
                    ), tint = Color.Blue)
                }
            }

            if (isRecording) {
                IconButton(
                    onClick = {
                        onStop()
                        isRecording = false
                        isTimerRunning = false
                        isRecorded = true
                        recordedTimeInSeconds=timeInSeconds;
                        timeInSeconds = 0
                    },
                    modifier = Modifier.size(72.dp)
                ) {
                    Icon(Icons.Filled.Stop, contentDescription = stringResource(R.string.stop), tint = Color.Red,modifier = Modifier.size(100.dp))
                }
            }

            if (isRecorded && !isRecording) {
                Row(
                    horizontalArrangement = Arrangement.Center,
                    verticalAlignment = Alignment.CenterVertically
                ) {
                    IconButton(
                        onClick = {
                            if (isPlaying) {
                                onPause()
                                isPaused=true;
                                isPlaying = false
                            } else {
                                onPlay(
                                   isPaused, { isPaused = false },
                                    { isPlaying = false; isPaused=false; audioPlayTimeInSeconds = 0 }
                                )
                                isPlaying = true
                            }
                        },
                        modifier = Modifier.size(72.dp)
                    ) {
                        Icon(
                            imageVector = if (isPlaying) Icons.Filled.Pause else Icons.Filled.PlayArrow,
                            contentDescription = if (isPlaying) stringResource(R.string.pause) else stringResource(R.string.play),
                            tint = Color.White,
                            modifier = Modifier.size(100.dp)
                        )
                    }

                    if (isPlaying) {
                        IconButton(
                            onClick = {
                                onStopPlayback()
                                audioPlayTimeInSeconds = 0
                                isPlaying = false
                                isPaused = false;
                            },
                            modifier = Modifier.size(72.dp)
                        ) {
                            Icon(Icons.Filled.Stop, contentDescription = stringResource(R.string.stop_playback), tint = Color.Red,modifier = Modifier.size(100.dp))
                        }
                    }
                }

                Spacer(modifier = Modifier.height(16.dp))

                Button(onClick = onSave,
                    colors = ButtonDefaults.buttonColors(
                        contentColor = Color.White,
                        containerColor = Color.Blue
                    ),
                    enabled = !isPlaying,
                    modifier = Modifier
                        .width(220.dp)
                        .height(48.dp)) {
                    Text(stringResource(R.string.save), color = Color.White)
                }
            }

            Spacer(modifier = Modifier.height(16.dp))
            Button(onClick = {
                if(isRecorded){
                    isRecording=false;
                    isRecorded=false;
                    isPlaying=false;
                    isPaused=false;
                    isTimerRunning=false;
                    recordedTimeInSeconds=0;
                    timeInSeconds=0;
                    audioPlayTimeInSeconds=0;
                }else{
                    onCancel();
                } },
                enabled = !isPlaying&&!isRecording,
                colors = ButtonDefaults.buttonColors(
                    contentColor = Color.White,
                    containerColor = if(isRecorded) Color.Red else BlueLight
                ),
                modifier = Modifier
                    .width(220.dp)
                    .height(52.dp)) {
                Text( if(isRecorded) stringResource(R.string.cancel) else stringResource(R.string.back), color = Color.White)
            }
        }


        Spacer(modifier = Modifier.size(0.dp))
    }

    if (showPermissionDialog) {
        AlertDialog(
            containerColor = Color.Black,
            onDismissRequest = { showPermissionDialog = false },
            title = { Text(stringResource(R.string.mic_permission_required), color = Color.White) },
            text = { Text(stringResource(R.string.mic_permission_description), color = Color.White) },
            confirmButton = {
                Button(onClick = {
                    showPermissionDialog = false
                    openAppSettings(context)
                }) {
                    Text(stringResource(R.string.open_settings))
                }
            },
            dismissButton = {
                Button(onClick = { showPermissionDialog = false }) {
                    Text(stringResource(R.string.cancel))
                }
            }
        )
    }
}

private fun openAppSettings(context: Context) {
    val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
        data = Uri.parse("package:${context.packageName}")
    }
    context.startActivity(intent)
}

--- FILE_END ---

--- FILE_START ---
PATH: app\src\main\java\com\anthroteacher\intentionrepeater\Settings.kt
--- CONTENT ---
package com.anthroteacher.intentionrepeater

import android.annotation.SuppressLint
import android.app.NotificationManager
import android.content.Context
import android.content.Intent
import android.content.SharedPreferences
import android.net.Uri
import android.os.Build
import android.os.Bundle
import android.provider.Settings
import android.widget.Toast
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.annotation.RequiresApi
import androidx.compose.foundation.background
import androidx.compose.foundation.gestures.detectTapGestures
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.layout.widthIn
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.text.ClickableText
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.ArrowDropDown
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.DropdownMenuItem
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.ExposedDropdownMenuBox
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.material3.TextField
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.focus.FocusRequester
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.layout.onGloballyPositioned
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalFocusManager
import androidx.compose.ui.platform.LocalLifecycleOwner
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.AnnotatedString
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.core.app.NotificationManagerCompat
import androidx.core.content.FileProvider
import androidx.core.text.isDigitsOnly
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import com.anthroteacher.intentionrepeater.ui.theme.IntentionRepeaterTheme
import java.io.File
import java.util.Locale

class SettingsActivity : ComponentActivity() {
    private lateinit var sharedPreferences: SharedPreferences

    @RequiresApi(Build.VERSION_CODES.TIRAMISU)
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Initialize SharedPreferences
        sharedPreferences = getSharedPreferences("AppPreferences", Context.MODE_PRIVATE)

        // Load and apply the saved locale when the activity is created
        loadLocale()

        setContent {
            IntentionRepeaterTheme {
                // Make the SettingsScreen scrollable
                SettingsScreen(
                    currentLocale = sharedPreferences.getString("Language", "en") ?: "en",
                    onLanguageChange = { newLocale ->
                        saveLanguageToPreferences(newLocale)
                        setLocale(this, newLocale) // Apply the new locale
                        recreate() // Recreate the activity to reflect changes
                    },
                    currentDuration = sharedPreferences.getLong("Duration", 0L).toString(),
                    onDurationChange = { newDuration ->
                        var value = 0L
                        if (newDuration.isNotEmpty() && newDuration.isDigitsOnly()) {
                            value = newDuration.toLong()
                        }
                        sharedPreferences.edit().putLong("Duration", value).apply()
                    }
                )
            }
        }
    }

    // Function to load and apply the saved locale from SharedPreferences
    private fun loadLocale() {
        val savedLanguage = sharedPreferences.getString("Language", "en") ?: "en"
        setLocale(this, savedLanguage) // Apply the saved or default locale
    }

    // Function to save the selected language to SharedPreferences
    private fun saveLanguageToPreferences(languageCode: String) {
        sharedPreferences.edit().putString("Language", languageCode).apply()
    }

    // Function to set the app's locale
    private fun setLocale(context: Context, languageCode: String) {
        val locale = Locale(languageCode)
        Locale.setDefault(locale)

        val resources = context.resources
        val config = resources.configuration
        config.setLocale(locale)
        config.setLayoutDirection(locale)

        context.createConfigurationContext(config)
        resources.updateConfiguration(config, resources.displayMetrics)
    }

    // Apply the locale whenever the activity is resumed
    override fun onResume() {
        super.onResume()
        loadLocale() // Reload and apply the locale when the activity resumes
    }
}

@SuppressLint("ServiceCast")
@RequiresApi(Build.VERSION_CODES.TIRAMISU)
@Composable
fun SettingsScreen(
    currentLocale: String,
    onLanguageChange: (String) -> Unit,
    currentDuration : String,
    onDurationChange: (String)->Unit
) {
    val context = LocalContext.current
    val notificationManagerCompat = NotificationManagerCompat.from(context)
    var linksVisible by remember { mutableStateOf(false)}
    val focusManager = LocalFocusManager.current
    var maxWidth by remember { mutableStateOf(0) }

    // Mutable state to track the notification status
    var notificationEnabled by remember { mutableStateOf(notificationManagerCompat.areNotificationsEnabled()) }

    // Get the lifecycle owner to observe lifecycle changes
    val lifecycleOwner = LocalLifecycleOwner.current

    // State to keep track of selected language
    var selectedLanguage by remember { mutableStateOf(currentLocale) }
    var selectedDuration by remember { mutableStateOf(currentDuration) }

    // Observe the lifecycle state of the composable
    DisposableEffect(lifecycleOwner) {
        val observer = LifecycleEventObserver { _, event ->
            if (event == Lifecycle.Event.ON_RESUME) {
                // Recheck the notification status when the user returns to the screen
                notificationEnabled = notificationManagerCompat.areNotificationsEnabled()
            }
        }
        lifecycleOwner.lifecycle.addObserver(observer)

        onDispose {
            lifecycleOwner.lifecycle.removeObserver(observer)
        }
    }

    // Create a ScrollState to control the vertical scroll
    val scrollState = rememberScrollState()

    // Set the background color to black
    Column(
        modifier = Modifier
            .fillMaxSize()
            .background(Color.Black)
            .verticalScroll(scrollState)
            .pointerInput(Unit) {
                detectTapGestures(onTap = {
                    focusManager.clearFocus()
                })
            }, // Make the Column scrollable vertically
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Spacer(modifier = Modifier.height(32.dp))
        // Heading text in white
        Text(
            text = stringResource(R.string.intention_repeater_settings),
            style = MaterialTheme.typography.headlineSmall,
            color = Color.White
        )
        Spacer(modifier = Modifier.height(16.dp))

        // Button for managing notifications
        Button(
            onClick = {
                // Open the app's notification settings page
                val intent = Intent().apply {
                    action = Settings.ACTION_APP_NOTIFICATION_SETTINGS
                    putExtra(Settings.EXTRA_APP_PACKAGE, context.packageName)
                }
                context.startActivity(intent)
            },
            colors = ButtonDefaults.buttonColors(
                containerColor = Color.Blue,
                contentColor = Color.White
            )
        ) {
            Text(
                text = stringResource(R.string.manage_notifications)
            )
        }

        Spacer(modifier = Modifier.height(8.dp))

        // Notification Status Message
        NotificationStatusMessage(enabled = notificationEnabled)

        Spacer(modifier = Modifier.height(16.dp))

        // "Open Notes File" button with matching style
        Button(
            onClick = { openNotesFile(context) },
            modifier = Modifier,
            colors = ButtonDefaults.buttonColors(
                containerColor = Color.Blue,
                contentColor = Color.White
            )
        ) {
            Text(stringResource(R.string.open_notes_for_intentions))
        }

        Spacer(modifier = Modifier.height(16.dp))

        // Language dropdown
        Column(modifier = Modifier.padding(16.dp)) {
            LanguageDropdown(
                currentLocale = selectedLanguage,
                onLanguageSelected = { newLanguage ->
                    selectedLanguage = newLanguage
                }
            )
        }

        Spacer(modifier = Modifier.height(8.dp))

        // "Update Language" button
        Button(
            onClick = {
                onLanguageChange(selectedLanguage)  // Use selectedLanguage instead of currentLocale
            },
            modifier = Modifier
                .padding(8.dp)
                .align(Alignment.CenterHorizontally)
        ) {
            Text(stringResource(R.string.update_language))
        }
        Row(
            modifier = Modifier
                .padding(8.dp)
                .fillMaxWidth(),
            horizontalArrangement = Arrangement.Start
        ){
            DurationInputField(duration = selectedDuration) { newDuration ->
                selectedDuration=newDuration
                onDurationChange(newDuration)
            }
        }
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.Center
        ) {
            ClickableText(
                text = AnnotatedString(stringResource(R.string.links)),
                modifier = Modifier.padding(8.dp),
                onClick = {
                    linksVisible=!linksVisible;
                },
                style = TextStyle(color = Color.White,
                    fontSize = 14.sp,
                    fontFamily = FontFamily.Serif,
                    fontWeight = FontWeight.Bold)
            )
        }
        Spacer(modifier = Modifier.height(10.dp))

        if(linksVisible){
            // Row for Website and Forum buttons
            Column(
                modifier = Modifier.fillMaxWidth(),
                verticalArrangement = Arrangement.Center,
                horizontalAlignment = Alignment.CenterHorizontally
            ) {
                // Using button composables from MainActivity
                WebsiteButton(Modifier
                    //.fillMaxWidth(0.4f)
                    .width(220.dp)
                    .height(48.dp))
                Spacer(modifier = Modifier.height(16.dp)) // Spacer between Website and Forum buttons
                ForumButton(Modifier
                    //.fillMaxWidth(0.4f)
                    .width(220.dp)
                    .height(48.dp))
                Spacer(modifier = Modifier.height(16.dp)) // Spacer between Website and Forum buttons
                EulaButton(Modifier
                    //.fillMaxWidth(0.4f)
                    .width(220.dp)
                    .height(48.dp))
                Spacer(modifier = Modifier.height(16.dp)) // Spacer between EULA and Privacy buttons
                PrivacyPolicyButton(Modifier
                    //.fillMaxWidth(0.4f)
                    .width(220.dp)
                    .height(48.dp))
            }

            Spacer(modifier = Modifier.height(16.dp)) // Spacer between rows
        }

        Button(
            onClick = {
                val url = "https://multihasher.intentionrepeater.com"
                val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
                context.startActivity(intent)
            },
            colors = ButtonDefaults.buttonColors(
                contentColor = Color.White,
                containerColor = Color.Blue
            ),
            modifier = Modifier
                .width(220.dp)
                .height(48.dp)
        ) {
            Text(
                text = stringResource(R.string.multihasher_app),
                color = Color.White,
                fontSize = 14.sp,
                fontFamily = FontFamily.Serif
            )
        }

        Spacer(modifier = Modifier.height(16.dp))

        // Back Button
        Button(
            onClick = { (context as? ComponentActivity)?.finish() },
            modifier = Modifier
                .width(220.dp)
                .height(52.dp)
        ) {
            Text(stringResource(R.string.back))
        }
    }
}

// Function to handle opening the notes file
@SuppressLint("QueryPermissionsNeeded")
// Function to handle opening the notes file
fun openNotesFile(context: Context) {
    val notesFile = File(context.filesDir, "intention_repeater_notes.txt")

    // Check if the file exists, and create it if it doesn't
    if (!notesFile.exists()) {
        notesFile.createNewFile()
    }

    // Create a URI for the file using FileProvider
    val uri = FileProvider.getUriForFile(
        context,
        "${context.packageName}.provider",
        notesFile
    )

    // Create an intent to open the file
    val intent = Intent(Intent.ACTION_VIEW).apply {
        setDataAndType(uri, "text/plain")
        flags = Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_GRANT_WRITE_URI_PERMISSION
    }

    // Check if there is an app to handle the intent
    if (intent.resolveActivity(context.packageManager) != null) {
        context.startActivity(intent)
    } else {
        // Show a message or prompt the user to install a text editor
        Toast.makeText(context,
            context.getString(R.string.no_text_editor_found_please_install_one_from_the_play_store), Toast.LENGTH_LONG).show()
    }
}

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun LanguageDropdown(
    currentLocale: String,
    onLanguageSelected: (String) -> Unit // Renamed to onLanguageSelected for clarity
) {
    var expanded by remember { mutableStateOf(false) }
    var selectedLanguage by remember { mutableStateOf(currentLocale) }

    ExposedDropdownMenuBox(
        expanded = expanded,
        onExpandedChange = { expanded = !expanded }
    ) {
        TextField(
            readOnly = true,
            value = languages.find { it.code == selectedLanguage }?.displayName ?: "Select Language",
            onValueChange = {},
            modifier = Modifier
                .fillMaxWidth()
                .menuAnchor(),
            trailingIcon = {
                Icon(
                    imageVector = Icons.Filled.ArrowDropDown,
                    contentDescription = "Dropdown Icon"
                )
            }
        )
        ExposedDropdownMenu(
            expanded = expanded,
            onDismissRequest = { expanded = false }
        ) {
            languages.forEach { language ->
                DropdownMenuItem(
                    text = { Text(language.displayName) },
                    onClick = {
                        selectedLanguage = language.code
                        expanded = false
                        onLanguageSelected(selectedLanguage) // Pass the selected language up
                    }
                )
            }
        }
    }
}


@Composable
fun DurationInputField(duration:String,onDurationChange:(String)->Unit) {
    Column {
        Text(
            text = "Duration", // The label for the TextField
            style = MaterialTheme.typography.bodyLarge, // Set the text style as per your theme
            modifier = Modifier.fillMaxWidth()
        )
        TextField(
            value = duration.toString(),
            onValueChange = { newText ->
                // Update the state with the new text
                onDurationChange(newText)
            },
            label = { Text(stringResource(R.string.seconds)) },
            modifier = Modifier.fillMaxWidth(),
            keyboardOptions = KeyboardOptions.Default.copy(keyboardType = KeyboardType.Number)
        )
    }
}

@Composable
fun NotificationStatusMessage(enabled: Boolean) {
    // Construct the message with color highlighting for ENABLED/ DISABLED and default white text
    val statusText = buildAnnotatedString {
        // Set the default color for the rest of the text to white
        withStyle(style = SpanStyle(color = Color.White)) {
            if (enabled) {
                append(stringResource(R.string.notifications_enabled))
            } else {
                append(stringResource(R.string.notifications_disabled))
            }
        }
    }

    // Display the styled text
    Text(
        text = statusText,
        style = MaterialTheme.typography.bodyMedium,
        modifier = Modifier.padding(16.dp)
    )
}
--- FILE_END ---

--- FILE_START ---
PATH: app\src\main\java\com\anthroteacher\intentionrepeater\TimerViewModel.kt
--- CONTENT ---
package com.anthroteacher.intentionrepeater

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel

class TimerViewModel : ViewModel() {

    private val _timerRunning = MutableLiveData<Boolean>()
    val timerRunning: LiveData<Boolean> get() = _timerRunning

    fun setTimerRunning(value: Boolean) {
        _timerRunning.value = value
    }
}
--- FILE_END ---

--- FILE_START ---
PATH: app\src\main\java\com\anthroteacher\intentionrepeater\db\Intention.kt
--- CONTENT ---
data class Intention(
    val id: Int = 0,
    var title: String,
    var intention: String,
    var multiplier: Double,
    var frequency: String,
    var awakeDevice: Boolean,
    var boostPower: Boolean,
    var timerStartedAt: Long,
    var iterationCompleted: Double,
    var iterationCount: String,
    var timerRunning: Boolean=false,
    var isNotification: Boolean = false,
    var targetLength: Long,

    @Transient
    var newIntention: String = "",
    @Transient
    var mutableIntention: String = "",
    @Transient
    var newMultiplier: Long = 0L,
    @Transient
    var iterationsInLastSecond: Double = 0.0,
    @Transient
    var lastSecond: Long = System.nanoTime(),
    @Transient
    var isFirstIterationSet: Boolean = false,
    @Transient
    var iterations: Double = 0.0,
    @Transient
    var elapsedTime: Long = 0L,
    @Transient
    var lastTime: String = "",
    @Transient
    var updatedIterationCount: String = "",
    @Transient
    var lastHourMark:Long =-1
)

--- FILE_END ---

--- FILE_START ---
PATH: app\src\main\java\com\anthroteacher\intentionrepeater\db\IntentionDBHelper.kt
--- CONTENT ---
package com.anthroteacher.intentionrepeater.db

import Intention
import android.annotation.SuppressLint
import android.content.ContentValues
import android.content.Context
import android.database.sqlite.SQLiteDatabase
import android.database.sqlite.SQLiteOpenHelper
import android.util.Log

class IntentionDBHelper(context: Context) :
    SQLiteOpenHelper(context, "intentions.db", null, 1) {

    override fun onCreate(db: SQLiteDatabase) {
        db.execSQL("""
                CREATE TABLE intentions (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    title TEXT NOT NULL,
                    intention TEXT,
                    multiplier REAL,
                    frequency TEXT,
                    awake_device INTEGER,
                    boost_power INTEGER,
                    timer_started_at INTEGER,
                    iteration_completed REAL,
                    iteration_count TEXT,
                    timer_running INTEGER DEFAULT 0,
                    is_notification INTEGER DEFAULT 0,
                    target_length INTEGER
                )
            """.trimIndent())
        db.execSQL("""
                INSERT INTO intentions (title, intention, multiplier, frequency, awake_device,boost_power, timer_started_at, iteration_completed,iteration_count,timer_running, is_notification,target_length)
            VALUES ('', '', 1, '1',1, 0, 0, 0,'',0, 1,0)
            """.trimIndent())
    }

    override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
        db.execSQL("DROP TABLE IF EXISTS intentions")
        onCreate(db)
    }

    fun insertIntention(intention: Intention): Long {
        val db = writableDatabase
        val values = ContentValues().apply {
            put("title", intention.title)
            put("intention", intention.intention)
            put("multiplier", intention.multiplier)
            put("frequency", intention.frequency)
            put("awake_device", if (intention.awakeDevice) 1 else 0)
            put("boost_power", if (intention.boostPower) 1 else 0)
            put("timer_started_at", intention.timerStartedAt)
            put("iteration_completed", intention.iterationCompleted)
            put("iteration_count", intention.iterationCount)
            put("timer_running",intention.timerRunning)
            put("is_notification", if (intention.isNotification) 1 else 0)
            put("target_length",intention.targetLength)
        }
        return db.insert("intentions", null, values)
    }

    fun updateIntention(intention: Intention): Int {
        val db = writableDatabase
        val values = ContentValues().apply {
            put("title", intention.title)
            put("intention", intention.intention)
            put("multiplier", intention.multiplier)
            put("frequency", intention.frequency)
            put("awake_device", if (intention.awakeDevice) 1 else 0)
            put("boost_power", if (intention.boostPower) 1 else 0)
            put("timer_started_at", intention.timerStartedAt)
            put("iteration_completed", intention.iterationCompleted)
            put("iteration_count", intention.iterationCount)
            put("timer_running",intention.timerRunning)
            put("is_notification", if (intention.isNotification) 1 else 0)
            put("target_length",intention.targetLength)
        }
        return db.update("intentions", values, "id = ?", arrayOf(intention.id.toString()))
    }

    fun deleteIntention(id: Int): Int {
        val db = writableDatabase
        val deleted = db.delete("intentions", "id = ?", arrayOf(id.toString()))

        val countCursor = db.rawQuery("SELECT COUNT(*) FROM intentions", null)
        countCursor.moveToFirst()
        val count = countCursor.getInt(0)
        countCursor.close()

        if (count == 0) {
            db.execSQL("""
            INSERT INTO intentions (title, intention, multiplier, frequency, awake_device,boost_power, timer_started_at, iteration_completed,iteration_count,timer_running, is_notification,target_length)
            VALUES ('', '', 1, '1',1, 0, 0, 0,'',0, 1,0)
        """.trimIndent())
        }

        return deleted
    }

    fun getAllIntentions(): List<Intention> {
        val db = readableDatabase
        val cursor = db.rawQuery("SELECT * FROM intentions", null)
        val list = mutableListOf<Intention>()

        if (cursor.moveToFirst()) {
            do {
                list.add(
                    Intention(
                        id = cursor.getInt(0),
                        title = cursor.getString(1),
                        intention = cursor.getString(2),
                        multiplier = cursor.getDouble(3),
                        frequency = cursor.getString(4),
                        awakeDevice = cursor.getInt(5) == 1,
                        boostPower = cursor.getInt(6)==1,
                        timerStartedAt = cursor.getLong(7),
                        iterationCompleted = cursor.getDouble(8),
                        iterationCount = cursor.getString(9),
                        timerRunning = cursor.getInt(10)==1,
                        isNotification = cursor.getInt(11) == 1,
                        targetLength = cursor.getLong(12)
                    )
                )
            } while (cursor.moveToNext())
        }
        cursor.close()
        return list
    }


    fun getStartIntentions(): List<Intention> {
        val db = readableDatabase
        val cursor = db.rawQuery("SELECT * FROM intentions WHERE timer_running=1", null)
        val list = mutableListOf<Intention>()

        if (cursor.moveToFirst()) {
            do {
                list.add(
                    Intention(
                        id = cursor.getInt(0),
                        title = cursor.getString(1),
                        intention = cursor.getString(2),
                        multiplier = cursor.getDouble(3),
                        frequency = cursor.getString(4),
                        awakeDevice = cursor.getInt(5) == 1,
                        boostPower = cursor.getInt(6)==1,
                        timerStartedAt = cursor.getLong(7),
                        iterationCompleted = cursor.getDouble(8),
                        iterationCount = cursor.getString(9),
                        timerRunning = cursor.getInt(10)==1,
                        isNotification = cursor.getInt(11) == 1,
                        targetLength = cursor.getLong(12)
                    )
                )
            } while (cursor.moveToNext())
        }
        cursor.close()

        return list
    }


    fun getNotificationEnabledIntention(): Intention? {
        val db = readableDatabase
        val cursor = db.rawQuery("SELECT * FROM intentions WHERE is_notification = 1 LIMIT 1", null)
        val intention = if (cursor.moveToFirst()) {
            Intention(
                id = cursor.getInt(0),
                title = cursor.getString(1),
                intention = cursor.getString(2),
                multiplier = cursor.getDouble(3),
                frequency = cursor.getString(4),
                awakeDevice = cursor.getInt(5) == 1,
                boostPower = cursor.getInt(6)==1,
                timerStartedAt = cursor.getLong(7),
                iterationCompleted = cursor.getDouble(8),
                iterationCount = cursor.getString(9),
                timerRunning = cursor.getInt(10)==1,
                isNotification = cursor.getInt(11) == 1,
                targetLength = cursor.getLong(12)
            )
        } else null
        cursor.close()
        return intention
    }

    fun setNotificationIntention(id: Int) {
        val db = writableDatabase
        db.beginTransaction()
        try {
            // Clear all
            db.execSQL("UPDATE intentions SET is_notification = 0")
            // Set selected
            val values = ContentValues().apply { put("is_notification", 1) }
            db.update("intentions", values, "id = ?", arrayOf(id.toString()))
            db.setTransactionSuccessful()
        } finally {
            db.endTransaction()
        }
    }

    fun ensureNotificationExists() {
        val db = writableDatabase
        val cursor = db.rawQuery("SELECT COUNT(*) FROM intentions WHERE is_notification = 1", null)
        cursor.moveToFirst()
        val hasNotification = cursor.getInt(0) > 0
        cursor.close()

        if (!hasNotification) {
            // Set notification on the first available intention
            db.execSQL("UPDATE intentions SET is_notification = 1 WHERE id = (SELECT id FROM intentions LIMIT 1)")
        }
    }

    fun stopAllIntention() {
        val db = writableDatabase
        db.execSQL("UPDATE intentions SET timer_running = 0,timer_started_at=0,iteration_completed=0.0,target_length=0,iteration_count=''")
    }


    fun getIntentionById(id: Int):Intention {
        val db = readableDatabase
        val cursor = db.rawQuery("SELECT * FROM intentions WHERE id=?", arrayOf(id.toString()))
        cursor.moveToFirst();

        val intention = Intention(
            id = cursor.getInt(0),
            title = cursor.getString(1),
            intention = cursor.getString(2),
            multiplier = cursor.getDouble(3),
            frequency = cursor.getString(4),
            awakeDevice = cursor.getInt(5) == 1,
            boostPower = cursor.getInt(6)==1,
            timerStartedAt = cursor.getLong(7),
            iterationCompleted = cursor.getDouble(8),
            iterationCount = cursor.getString(9),
            timerRunning = cursor.getInt(10)==1,
            isNotification = cursor.getInt(11) == 1,
            targetLength = cursor.getLong(12)
        )
        cursor.close()

        return intention;
    }
}

--- FILE_END ---

--- FILE_START ---
PATH: app\src\main\java\com\anthroteacher\intentionrepeater\db\IntentionViewModel.kt
--- CONTENT ---
import android.app.Application
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.snapshots.SnapshotStateList
import androidx.lifecycle.AndroidViewModel
import com.anthroteacher.intentionrepeater.db.IntentionDBHelper
import Intention
import android.util.Log

class IntentionViewModel(application: Application) : AndroidViewModel(application) {
    private val dbHelper = IntentionDBHelper(application)

    private val _tabs = mutableStateListOf<Intention>()
    val tabs: SnapshotStateList<Intention> get() = _tabs

    init {
        ensureDefaultIntentionExists()
        loadTabs()
    }

    private fun ensureDefaultIntentionExists() {
        if (dbHelper.getAllIntentions().isEmpty()) {
            dbHelper.insertIntention(
                Intention(
                    title = "",
                    intention = "",
                    multiplier = 1.1,
                    frequency = "1",
                    awakeDevice = false,
                    boostPower = true,
                    timerStartedAt = 0L,
                    iterationCompleted = 0.0,
                    iterationCount = "",
                    timerRunning = false,
                    isNotification = true,
                    targetLength = 0
                )
            )
        } else {
            dbHelper.ensureNotificationExists() // optional safety check
        }
    }

    fun loadTabs() {
        val allIntentions = dbHelper.getAllIntentions()
        _tabs.clear()
        _tabs.addAll(allIntentions.map { it })
    }

    fun addIntention(intention: Intention):Long {
        val id = dbHelper.insertIntention(intention)
        loadTabs()
        return id;
    }

    fun updateIntention(intention: Intention) {
        dbHelper.updateIntention(intention)
        Log.d("TERS",dbHelper.getStartIntentions().toString())
        loadTabs()
    }

    fun deleteIntention(id: Int) {
        dbHelper.deleteIntention(id)
        ensureDefaultIntentionExists()
        loadTabs()
    }

    fun getNotificationIntention(): Intention? {
        return dbHelper.getNotificationEnabledIntention()
    }

    fun changeNotificationIntention(id: Int) {
        dbHelper.setNotificationIntention(id)
        loadTabs()
    }

    fun stopAllIntentions() {
        dbHelper.stopAllIntention()
    }

    fun setNotificationIntention(id: Int){
        dbHelper.setNotificationIntention(id);
        loadTabs();
    }

    fun getStartIntentions(): List<Intention> {
        return dbHelper.getStartIntentions()
    }
}

--- FILE_END ---

--- FILE_START ---
PATH: app\src\main\java\com\anthroteacher\intentionrepeater\ui\theme\Color.kt
--- CONTENT ---
package com.anthroteacher.intentionrepeater.ui.theme

import androidx.compose.ui.graphics.Color

val Purple80 = Color(0xFFD0BCFF)
val PurpleGrey80 = Color(0xFFCCC2DC)
val Pink80 = Color(0xFFEFB8C8)

val Purple40 = Color(0xFF6650a4)
val PurpleGrey40 = Color(0xFF625b71)
val Pink40 = Color(0xFF7D5260)

val BlueLight = Color(0xFF4B5C92)
val SafetyOrange = Color(0xFFFF8C00)
val FireRed = Color(0xFFFF4500)
--- FILE_END ---

--- FILE_START ---
PATH: app\src\main\java\com\anthroteacher\intentionrepeater\ui\theme\Theme.kt
--- CONTENT ---
package com.anthroteacher.intentionrepeater.ui.theme

import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.ui.platform.LocalContext

public val DarkColorScheme = darkColorScheme(
        primary = Purple80,
        secondary = PurpleGrey80,
        tertiary = Pink80
)

public val LightColorScheme = lightColorScheme(
        primary = Purple40,
        secondary = PurpleGrey40,
        tertiary = Pink40

        /* Other default colors to override
    background = Color(0xFFFFFBFE),
    surface = Color(0xFFFFFBFE),
    onPrimary = Color.White,
    onSecondary = Color.White,
    onTertiary = Color.White,
    onBackground = Color(0xFF1C1B1F),
    onSurface = Color(0xFF1C1B1F),
    */
)

@Composable
fun IntentionRepeaterTheme(
        darkTheme: Boolean = isSystemInDarkTheme(),
        // Dynamic color is available on Android 12+
        dynamicColor: Boolean = true,
        content: @Composable () -> Unit
) {
    val colorScheme = when {
        dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
            val context = LocalContext.current
            if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
        }

        darkTheme -> DarkColorScheme
        else -> LightColorScheme
    }

    MaterialTheme(
            colorScheme = colorScheme,
            typography = Typography,
            content = content
    )
}
--- FILE_END ---

--- FILE_START ---
PATH: app\src\main\java\com\anthroteacher\intentionrepeater\ui\theme\Type.kt
--- CONTENT ---
package com.anthroteacher.intentionrepeater.ui.theme

import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp

// Set of Material typography styles to start with
val Typography = Typography(
        bodyLarge = TextStyle(
                fontFamily = FontFamily.Default,
                fontWeight = FontWeight.Normal,
                fontSize = 16.sp,
                lineHeight = 24.sp,
                letterSpacing = 0.5.sp
        )
        /* Other default text styles to override
    titleLarge = TextStyle(
        fontFamily = FontFamily.Default,
        fontWeight = FontWeight.Normal,
        fontSize = 22.sp,
        lineHeight = 28.sp,
        letterSpacing = 0.sp
    ),
    labelSmall = TextStyle(
        fontFamily = FontFamily.Default,
        fontWeight = FontWeight.Medium,
        fontSize = 11.sp,
        lineHeight = 16.sp,
        letterSpacing = 0.5.sp
    )
    */
)
--- FILE_END ---

--- FILE_START ---
PATH: app\src\test\java\com\example\intentionrepeater\ExampleUnitTest.kt
--- CONTENT ---
package com.anthroteacher.intentionrepeater

import org.junit.Test

import org.junit.Assert.*

/**
 * Example local unit test, which will execute on the development machine (host).
 *
 * See [testing documentation](http://d.android.com/tools/testing).
 */
class ExampleUnitTest {
    @Test
    fun addition_isCorrect() {
        assertEquals(4, 2 + 2)
    }
}
--- FILE_END ---

**--- MANIFEST STRUCTURE ---**
--- FILE_START ---
PATH: app\src\main\AndroidManifest.xml
--- CONTENT ---
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
    <uses-permission android:name="android.permission.WAKE_LOCK" />
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE" />
    <uses-permission android:name="android.permission.RECORD_AUDIO"/>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>


    <application
        android:allowBackup="false"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.IntentionRepeater"
        tools:targetApi="31">
        <activity android:name=".SettingsActivity" />
        <activity android:name=".RecordVoiceIntentionActivity" />
        <activity
            android:name=".MainActivity"
            android:configChanges="orientation"
            android:exported="true"
            android:label="@string/app_name"
            android:launchMode="singleTask"
            android:theme="@style/Theme.IntentionRepeater">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <provider
            android:name="androidx.core.content.FileProvider"
            android:authorities="${applicationId}.provider"
            android:exported="false"
            android:grantUriPermissions="true">
            <meta-data
                android:name="android.support.FILE_PROVIDER_PATHS"
                android:resource="@xml/file_paths" />
        </provider>

        <service
            android:name=".TimerForegroundService"
            android:exported="true"
            android:foregroundServiceType="specialUse"
            tools:ignore="ForegroundServicePermission"></service>

        <meta-data
            android:name="android.locale_config"
            android:resource="@xml/locales_config" />
    </application>

</manifest>
--- FILE_END ---

--- FILE_START ---
PATH: app\src\main\res\drawable\ic_launcher_background.xml
--- CONTENT ---
<?xml version="1.0" encoding="utf-8"?>
<vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:width="108dp"
    android:height="108dp"
    android:viewportWidth="108"
    android:viewportHeight="108">
    <path
        android:fillColor="#3DDC84"
        android:pathData="M0,0h108v108h-108z" />
    <path
        android:fillColor="#00000000"
        android:pathData="M9,0L9,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M19,0L19,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M29,0L29,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M39,0L39,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M49,0L49,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M59,0L59,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M69,0L69,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M79,0L79,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M89,0L89,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M99,0L99,108"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,9L108,9"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,19L108,19"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,29L108,29"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,39L108,39"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,49L108,49"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,59L108,59"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,69L108,69"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,79L108,79"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,89L108,89"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M0,99L108,99"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M19,29L89,29"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M19,39L89,39"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M19,49L89,49"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M19,59L89,59"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M19,69L89,69"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M19,79L89,79"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M29,19L29,89"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M39,19L39,89"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M49,19L49,89"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M59,19L59,89"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M69,19L69,89"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
    <path
        android:fillColor="#00000000"
        android:pathData="M79,19L79,89"
        android:strokeWidth="0.8"
        android:strokeColor="#33FFFFFF" />
</vector>

--- FILE_END ---

--- FILE_START ---
PATH: app\src\main\res\layout\activity_links.xml
--- CONTENT ---
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".`LinksActivity.kt`">

</androidx.constraintlayout.widget.ConstraintLayout>
--- FILE_END ---

**--- MANIFEST DEFAULT STRINGS (ENGLISH) ---**
<resources>
    <string name="app_name">Intention Repeater</string>
    <string name="intention_repeater_header">Intention Repeater</string>
    <string name="by_anthro_teacher">by Anthro Teacher</string>
    <string name="mult_0">Mult [%1$s]: 0</string>
    <string name="_3_hz_classic">3 Hz (Classic)</string>
    <string name="_7_83_hz_schumann_resonance_optimal">7.83 Hz Schumann Resonance (Optimal)</string>
    <string name="str_maximum_frequency">Maximum Frequency</string>
    <string name="power_boost_uses_sha512_encoding">Power Boost - Uses Sha512 Encoding</string>
    <string name="keep_device_awake_3_hz_or_7_83_hz_only">Keep Device Awake (3 Hz or 7.83 Hz only)</string>
    <string name="str_iterations">%1$s Iterations (%2$s)</string>
    <string name="str_stop">STOP</string>
    <string name="str_start">START</string>
    <string name="str_load_file">LOAD FILE</string>
    <string name="str_version">Version %1$s</string>
    <string name="intention_repeater_settings">Intention Repeater Settings</string>
    <string name="manage_notifications">Manage Notifications</string>
    <string name="notifications_are">"Notifications are "</string>
    <string name="enabled">\u0020ENABLED\u0020</string>
    <string name="disabled">\u0020DISABLED\u0020</string>
    <string name="notification_on_message">. When running, the notification will update each second with elapsed time, current frequency, and number of iterations.</string>
    <string name="notification_off_message">. You can enable notifications to view elapsed time, current frequency, and number of iterations when running as a notification.</string>
    <string name="open_notes_for_intentions">Open Notes for Intentions</string>
    <string name="website">Website</string>
    <string name="forum">Forum</string>
    <string name="eula">EULA</string>
    <string name="privacy">Privacy</string>
    <string name="back">Back</string>
    <string name="prevents_device_from_sleeping_during_3_hz_or_7_83_hz_operations_increases_battery_usage">Prevents device from sleeping during 3 Hz or 7.83 Hz operations. Increases battery usage.</string>
    <string name="settings">Settings</string>
    <string name="reset">RESET</string>
    <string name="loading_intention">Loading Intention...</string>
    <string name="_0_iterations_0_hz">0 Iterations (0 Hz)</string>
    <string name="update_language">Update Language</string>
    <string name="no_text_editor_found_please_install_one_from_the_play_store">No text editor found. Please install one from the Play Store.</string>
    <string name="formatted_0_iterations">0 Iterations (0 Hz)</string>
    <string name="enter_intentions">Enter Intentions</string>
    <string name="Hz">Hz</string>
    <string name="kHz">kHz</string>
    <string name="MHz">MHz</string>
    <string name="GHz">GHz</string>
    <string name="THz">THz</string>
    <string name="PHz">PHz</string>
    <string name="EHz">EHz</string>
    <string name="Iterations">Iterations</string>
    <string name="k">k</string>
    <string name="M">M</string>
    <string name="B">B</string>
    <string name="T">T</string>
    <string name="q">q</string>
    <string name="Q">Q</string>
    <string name="s">s</string>
    <string name="S">S</string>

    <string name="show_intentions_update">To show intentions update</string>

    <string name="notifications_enabled">Notifications are \u0020ENABLED\u0020. When running, the notification will update each second with elapsed time, current frequency, and number of iterations.</string>
    <string name="notifications_disabled">Notifications are \u0020DISABLED\u0020. You can enable notifications to view elapsed time, current frequency, and number of iterations when running as a notification.</string>
    <string name="three_herz_classic">3 Hz (Classic)</string>
    <string name="schumann_resonance">7.83 Hz Schumann Resonance</string>
    <string name="prevents_device_sleeping">Prevents device from sleeping during 3 Hz or 7.83 Hz operations. Increases battery usage.</string>
    <string name="iterations_zero_hz">0 Iterations (0 Hz)</string>
    <string name="duration">Duration</string>
    <string name="seconds">Seconds</string>
    <string name="intention_repeater_finished">Intention Repeater Finished</string>
    <string name="finished">Finished: %1$s</string>

    <string name="multiplier">Multiplier [%1$s]: 0</string>
    <string name="multihasher_app">Multihasher App</string>
    <string name="links">Links...</string>


    <string name="keep_device_awake">Keep Device Awake (3 Hz, 7.83 Hz or once per hour only)</string>
    <string name="once_per_hour">Once per Hour (Optimal)</string>
    <string name="record_voice_intention">Record Voice Intention</string>
    <string name="record_voice_description">This records your voice (which has emotion and energy behind it) and inserts it into the Intention. It provides a better method of repeating your intention than text. Records up to 5 minutes.</string>
    <string name="recording">Recording...</string>
    <string name="playing">Playing...</string>
    <string name="paused">Paused</string>
    <string name="tap_play_listen">Tap Play to listen</string>
    <string name="tap_mic_record">Tap Mic to record</string>
    <string name="record">Record</string>
    <string name="stop">Stop</string>
    <string name="play">Play</string>
    <string name="pause">Pause</string>
    <string name="stop_playback">Stop Playback</string>
    <string name="save">Save</string>
    <string name="cancel">Cancel</string>

    <string name="mic_permission_required">Permission Required</string>
    <string name="mic_permission_description">This app needs microphone access to record your voice. Please enable it in app settings.</string>
    <string name="open_settings">Open Settings</string>
</resources>